Changeset c7806122

doc/LaTeXmacros/common.tex

-                      r91fb850
+                      rc7806122
 %% Created On       : Sat Apr  9 10:06:17 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Fri Sep  4 13:56:52 2020
 %% Update Count     : 383
+%% Last Modified On : Wed Sep 23 21:21:55 2020
+%% Update Count     : 454
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \newlength{\parindentlnth}
 \setlength{\parindentlnth}{\parindent}
-\newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}}
-\newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
-\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
-\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
-\newlength{\columnposn}
-\setlength{\gcolumnposn}{2.5in}
-\setlength{\columnposn}{\gcolumnposn}
-\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
-\newcommand{\CRT}{\global\columnposn=\gcolumnposn}
-% allow escape sequence in lstinline
-%\usepackage{etoolbox}
-%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
 \usepackage{pslatex}                                    % reduce size of san serif font
 …
 \usepackage{listings}                                                                   % format program code
 \usepackage{lstlang}
+\makeatletter
+\newcommand{\LstBasicStyle}[1]{{\lst@basicstyle{#1}}}
+\newcommand{\LstKeywordStyle}[1]{{\lst@basicstyle{\lst@keywordstyle{#1}}}}
+\newcommand{\LstCommentStyle}[1]{{\lst@basicstyle{\lst@commentstyle{#1}}}}
+\newlength{\gcolumnposn}                                % temporary hack because lstlisting does not handle tabs correctly
+\newlength{\columnposn}
+\setlength{\gcolumnposn}{2.75in}
+\setlength{\columnposn}{\gcolumnposn}
+\newcommand{\C}[2][\@empty]{\ifx#1\@empty\else\global\setlength{\columnposn}{#1}\global\columnposn=\columnposn\fi\hfill\makebox[\textwidth-\columnposn][l]{\lst@basicstyle{\LstCommentStyle{#2}}}}
+\newcommand{\CRT}{\global\columnposn=\gcolumnposn}
+% allow escape sequence in lstinline
+%\usepackage{etoolbox}
+%\patchcmd{\lsthk@TextStyle}{\let\lst@DefEsc\@empty}{}{}{\errmessage{failed to patch}}
+% allow adding to lst literate
+\def\addToLiterate#1{\protect\edef\lst@literate{\unexpanded\expandafter{\lst@literate}\unexpanded{#1}}}
+\lst@Key{add to literate}{}{\addToLiterate{#1}}
+\makeatother
 \newcommand{\CFADefaults}{%
 …
 belowskip=3pt,
 % replace/adjust listing characters that look bad in sanserif
 literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
+literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.75ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptscriptstyle\land\,$}}1
         {~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
         {<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex\textgreater}2,
+moredelim=**[is][\color{red}]{?}{?},    % red highlighting ?...? (registered trademark symbol) emacs: C-q M-.
+}% lstset
+}% CFADefaults
+\ifdefined\CFALatin%
+\lstnewenvironment{cfa}[1][]{\CFADefaults
+\lstset{
+language=CFA,
+moredelim=**[is][\color{red}]{®}{®},    % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 moredelim=**[is][\color{blue}]{ß}{ß},   % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
 moredelim=**[is][\color{OliveGreen}]{¢}{¢}, % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
 moredelim=[is][\lstset{keywords={}}]{¶}{¶}, % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
+% replace/adjust listing characters that look bad in sanserif
+add to literate={`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
 }% lstset
+}% CFADefaults
+\newcommand{\CFAStyle}{%
+\CFADefaults
+\lstset{#1}
+}{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 \lstMakeShortInline©                                    % single-character for \lstinline
+}% CFAStyle
+\lstnewenvironment{cfa}[1][]
+{\CFADefaults\lstset{#1}}
+{}
+\else% extra Latin-1 escape characters
+\lstset{
+language=CFA,
+escapechar=\$,                                                  % LaTeX escape in CFA code
+moredelim=**[is][\color{red}]{@}{@},    % red highlighting `...` (backtick symbol)
+}% lstset
+\lstnewenvironment{cfa}[1][]{\CFADefaults
+\lstset{
+language=CFA,
+escapechar=\$,                                                  % LaTeX escape in CFA code
+moredelim=**[is][\color{red}]{@}{@},    % red highlighting `...` (backtick symbol)
+}% lstset
+\lstset{#1}
+}{}
+% inline code @...@ (at symbol)
+\lstMakeShortInline@                                    % single-character for \lstinline
+\fi%
 % Local Variables: %

doc/LaTeXmacros/lstlang.sty

-                      r91fb850
+                      rc7806122
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Tue Jan  8 14:40:33 2019
 %% Update Count     : 21
+%% Last Modified On : Wed Sep 23 22:40:04 2020
+%% Update Count     : 24
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
                 auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
                 coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
                 __float80, float80, __float128, float128, forall, ftype, _Generic, _Imaginary, __imag, __imag__,
+                __float80, float80, __float128, float128, forall, ftype, generator, _Generic, _Imaginary, __imag, __imag__,
                 inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
                 otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, thread,
+                otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, suspend, thread,
                 _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
                 virtual, __volatile, __volatile__, waitfor, when, with, zero_t,
 …
 % C++ programming language
+\lstdefinelanguage{C++}[ANSI]{C++}{}
+\lstdefinelanguage{C++}[ANSI]{C++}{
+        morekeywords={nullptr,}
+}
 % uC++ programming language, based on ANSI C++

doc/refrat/refrat.tex

-                      r91fb850
+                      rc7806122
 %% Created On       : Wed Apr  6 14:52:25 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Jan 31 17:30:23 2018
 %% Update Count     : 108
+%% Last Modified On : Thu Sep 24 16:34:51 2020
+%% Update Count     : 109
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{upquote}                                                                    % switch curled `'" to straight
 \usepackage{calc}
-\usepackage{xspace}
 \usepackage{varioref}                                                                   % extended references
-\usepackage{listings}                                                                   % format program code
 \usepackage[flushmargin]{footmisc}                                              % support label/reference in footnote
 \usepackage{latexsym}                                   % \Box glyph
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
+\input{common}                                          % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+\renewcommand{\UrlFont}{\small\sf}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\CFAStyle                                                                                               % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®}#1}}
+{}
+\newcommand{\CFALatin}{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 …
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
+\input{common}                                          % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+\renewcommand{\UrlFont}{\small\sf}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\CFADefaults                                                                                    % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
+{}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % Names used in the document.
 \newcommand{\Version}{\input{../../version}}
+\newcommand{\Version}{\input{build/version}}
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}

doc/theses/andrew_beach_MMath/thesis.tex

-                      r91fb850
+                      rc7806122
 \usepackage[toc,abbreviations]{glossaries-extra}
+% Main glossary entries -- definitions of relevant terminology
+\newglossaryentry{computer}
+{
+name=computer,
+description={A programmable machine that receives input data,
+               stores and manipulates the data, and provides
+               formatted output}
+}
+% Nomenclature glossary entries -- New definitions, or unusual terminology
+\newglossary*{nomenclature}{Nomenclature}
+\newglossaryentry{dingledorf}
+{
+type=nomenclature,
+name=dingledorf,
+description={A person of supposed average intelligence who makes incredibly
+               brainless misjudgments}
+}
+% List of Abbreviations (abbreviations are from the glossaries-extra package)
+\newabbreviation{aaaaz}{AAAAZ}{American Association of Amature Astronomers
+               and Zoologists}
+% List of Symbols
+\newglossary*{symbols}{List of Symbols}
+\newglossaryentry{rvec}
+{
+name={$\mathbf{v}$},
+sort={label},
+type=symbols,
+description={Random vector: a location in n-dimensional Cartesian space, where
+               each dimensional component is determined by a random process}
+}
+% Define all the glossaries.
+\input{glossaries}
 % Generate the glossaries defined above.

doc/theses/fangren_yu_COOP_S20/Report.tex

-                      r91fb850
+                      rc7806122
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
 \newcommand{\NOTE}{\textbf{NOTE}}
+\newcommand{\TODO}[1]{{\color{Purple}#1}}
 \setlength{\topmargin}{-0.45in}                                                 % move running title into header
 …
 \lstset{
 language=C++,                                                                                   % make C++ the default language
-escapechar=\$,                                                                                  % LaTeX escape in CFA code
-moredelim=**[is][\color{red}]{`}{`},
 }% lstset
-\lstMakeShortInline@%
 \lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{`}{`},#1}}
+{}
+{\lstset{language=C++,moredelim=**[is][\color{red}]{@}{@},#1}}{}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \section{Overview}
+cfa-cc is the reference compiler for the \CFA programming language, which is a non-
+object-oriented extension to C.
+\CFA attempts to introduce productive modern programming language features to C
+while maintaining as much backward-compatibility as possible, so that most existing C
+programs can seamlessly work with \CFA.
+Since the \CFA project was dated back to the early 2000s, and only restarted in the past
+few years, there is a significant amount of legacy code in the current compiler codebase,
+with little proper documentation available. This becomes a difficulty while developing new
+features based on the previous implementations, and especially while diagnosing
+problems.
+Currently, the \CFA team is also facing another problem: bad compiler performance. For
+the development of a new programming language, writing a standard library is an
+important part. The incompetence of the compiler causes building the library files to take
+tens of minutes, making iterative development and testing almost impossible. There is
+ongoing effort to rewrite the core data structure of the compiler to overcome the
+performance issue, but many bugs may appear during the work, and lack of documentation
+makes debugging extremely difficult.
+This developer's reference will be continuously improved and eventually cover the
+compiler codebase. For now, the focus is mainly on the parts being rewritten, and also the
+performance bottleneck, namely the resolution algorithm. It is aimed to provide new
+developers to the project enough guidance and clarify the purposes and behavior of certain
+functions which are not mentioned in the previous \CFA research papers.
+cfa-cc is the reference compiler for the \CFA programming language, which is a non-object-oriented extension to C.
+\CFA attempts to introduce productive modern programming language features to C while maintaining as much backward-compatibility as possible, so that most existing C programs can seamlessly work with \CFA.
+Since the \CFA project dates back to the early 2000s, and only restarted in the past few years, there is a significant amount of legacy code in the current compiler codebase with little documentation.
+The lack of documentation makes it difficult to develop new features from the current implementation and diagnose problems.
+Currently, the \CFA team is also facing poor compiler performance.
+For the development of a new programming language, writing standard libraries is an important component.
+The slow compiler causes building of the library files to take tens of minutes, making iterative development and testing almost impossible.
+There is an ongoing effort to rewrite the core data-structure of the compiler to overcome the performance issue, but many bugs have appeared during this work, and lack of documentation is hampering debugging.
+This developer's reference manual begins the documentation and should be continuously im\-proved until it eventually covers the entire compiler codebase.
+For now, the focus is mainly on the parts being rewritten, and also the primary performance bottleneck, namely the resolution algorithm.
+Its aimed is to provide new project developers with guidance in understanding the codebase, and clarify the purpose and behaviour of certain functions that are not mentioned in the previous \CFA research papers~\cite{Bilson03,Ditchfield92,Moss19}.
 \section{Compiler Framework}
+\CFA source code is first transformed into an abstract syntax tree (AST) by the parser before analyzed by the compiler.
 \subsection{AST Representation}
+Source code input is first transformed into abstract syntax tree (AST) representation by the
+parser before analyzed by the compiler.
+There are 4 major categories of AST nodes used by the compiler, along with some derived
+structures.
+\subsubsection{Declaration nodes}
+There are 4 major categories of AST nodes used by the compiler, along with some derived structures.
+\subsubsection{Declaration Nodes}
 A declaration node represents either of:
 \begin{itemize}
 \item
+Type declaration: struct, union, typedef or type parameter (see Appendix A.3)
 \item
 Variable declaration
 \item
 Function declaration
+type declaration: @struct@, @union@, @typedef@ or type parameter \TODO{(see Appendix A.3)}
+\item
+variable declaration
+\item
+function declaration
 \end{itemize}
 Declarations are introduced by standard C declarations, with the usual scoping rules.
+In addition, declarations can also be introduced by the forall clause (which is the origin
+of \CFA's name):
+In addition, declarations can also be qualified by the \lstinline[language=CFA]@forall@ clause (which is the origin of \CFA's name):
 \begin{cfa}
 forall (<$\emph{TypeParameterList}$> | <$\emph{AssertionList}$>)
+forall ( <$\emph{TypeParameterList}$> | <$\emph{AssertionList}$> )
         $\emph{declaration}$
 \end{cfa}
 Type parameters in \CFA are similar to \CC template type parameters. The \CFA
 declaration
+Type parameters in \CFA are similar to \CC template type parameters.
+The \CFA declaration
 \begin{cfa}
 forall (dtype T) ...
 \end{cfa}
 behaves similarly as the \CC template declaration
+behaves similarly to the \CC template declaration
 \begin{C++}
 template <typename T> ...
 \end{C++}
+Assertions are a distinctive feature of \CFA: contrary to the \CC template where
+arbitrary functions and operators can be used in a template definition, in a \CFA
+parametric function, operations on parameterized types must be declared in assertions.
+Assertions are a distinctive feature of \CFA, similar to \emph{interfaces} in D and Go, and \emph{traits} in Rust.
+Contrary to the \CC template where arbitrary functions and operators can be used in a template definition, in a \CFA parametric function, operations on parameterized types must be declared in assertions.
 Consider the following \CC template:
 \begin{C++}
 template <typename T> int foo(T t) {
         return bar(t) + baz(t);
+@template@ forall<typename T> T foo( T t ) {
+        return t + t * t;
+}
 \end{C++}
+Unless bar and baz are also parametric functions taking any argument type, they must be
+declared in the assertions, or otherwise the code will not compile:
+where there are no explicit requirements on the type @T@.
+Therefore, the \CC compiler must deduce what operators are required during textual (macro) expansion of the template at each usage.
+As a result, templates cannot be compiled.
+\CFA assertions specify restrictions on type parameters:
 \begin{cfa}
 forall (dtype T | { int bar(T); int baz(t); }) int foo (T t) {
         return bar(t) + baz(t);
+forall( dtype T | @{ T ?+?( T, T ); T ?*?( T, T ) }@ ) int foo ( T t ) {
+        return t + t * t;
+}
 \end{cfa}
+Assertions are written using the usual function declaration syntax. The scope of type
+parameters and assertions is the following declaration.
+\subsubsection{Type nodes}
+A type node represents the type of an object or expression.
+Named types reference the corresponding type declarations. The type of a function is its
+function pointer type (same as standard C).
+With the addition of type parameters, named types may contain a list of parameter values
+(actual parameter types).
+\subsubsection{Statement nodes}
+Statement nodes represent the statements in the program, including basic expression
+statements, control flows and blocks.
+Assertions are written using the usual \CFA function declaration syntax.
+Only types with operators ``@+@'' and ``@*@'' work with this function, and the function prototype is sufficient to allow separate compilation.
+Type parameters and assertions are used in the following compiler data-structures.
+\subsubsection{Type Nodes}
+Type nodes represent the type of an object or expression.
+Named types reference the corresponding type declarations.
+The type of a function is its function pointer type (same as standard C).
+With the addition of type parameters, named types may contain a list of parameter values (actual parameter types).
+\subsubsection{Statement Nodes}
+Statement nodes represent the executable statements in the program, including basic expression statements, control flows and blocks.
 Local declarations (within a block statement) are represented as declaration statements.
+\subsubsection{Expression nodes}
+Some expressions are represented differently in the compiler before and after resolution
 stage:
+\subsubsection{Expression Nodes}
+Some expressions are represented differently before and after the resolution stage:
 \begin{itemize}
 \item
+Name expressions: NameExpr pre-resolution, VariableExpr post-resolution
+\item
+Member expressions: UntypedMemberExpr pre-resolution, MemberExpr post-resolution
+\item
+Function call expressions (including overloadable operators): UntypedExpr pre-resolution, ApplicationExpr post-resolution
+Name expressions: @NameExpr@ pre-resolution, @VariableExpr@ post-resolution
+\item
+Member expressions: @UntypedMemberExpr@ pre-resolution, @MemberExpr@ post-resolution
+\item
+\begin{sloppypar}
+Function call expressions (including overloadable operators): @UntypedExpr@ pre-resolution, @ApplicationExpr@ post-resolution
+\end{sloppypar}
 \end{itemize}
 The pre-resolution representations contain only the symbols. Post-resolution results link
 them to the actual variable and function declarations.
+The pre-resolution representation contains only the symbols.
+Post-resolution links them to the actual variable and function declarations.
 \subsection{Compilation Passes}
+Compilation steps are implemented as passes, which follows a general structural recursion
+pattern on the syntax tree.
+The basic work flow of compilation passes follows preorder and postorder traversal on
+tree data structure, implemented with visitor pattern, and can be loosely described with
+the following pseudocode:
+\begin{C++}
+Pass::visit (node_t node) {
+        previsit(node);
+        if (visit_children)
+Compilation steps are implemented as passes, which follows a general structural recursion pattern on the syntax tree.
+The basic workflow of compilation passes follows preorder and postorder traversal on the AST data-structure, implemented with visitor pattern, and can be loosely described with the following pseudocode:
+\begin{C++}
+Pass::visit( node_t node ) {
+        previsit( node );
+        if ( visit_children )
                 for each child of node:
                         child.accept(this);
         postvisit(node);
+                        child.accept( this );
+        postvisit( node );
+}
 \end{C++}
+Operations in previsit() happen in preorder (top to bottom) and operations in
+postvisit() happen in postorder (bottom to top). The precise order of recursive
+operations on child nodes can be found in @Common/PassVisitor.impl.h@ (old) and
+@AST/Pass.impl.hpp@ (new).
+Implementations of compilation passes need to follow certain conventions:
+Operations in @previsit@ happen in preorder (top to bottom) and operations in @postvisit@ happen in postorder (bottom to top).
+The precise order of recursive operations on child nodes can be found in @Common/PassVisitor.impl.h@ (old) and @AST/Pass.impl.hpp@ (new).
+Implementations of compilation passes follow certain conventions:
 \begin{itemize}
 \item
+Passes \textbf{should not} directly override the visit method (Non-virtual Interface
+principle); if a pass desires different recursion behavior, it should set
+@visit_children@ to false and perform recursive calls manually within previsit or
+postvisit procedures. To enable this option, inherit from @WithShortCircuiting@ mixin.
+\item
+previsit may mutate the node but \textbf{must not} change the node type or return null.
+\item
+postvisit may mutate the node, reconstruct it to a different node type, or delete it by
+returning null.
+Passes \textbf{should not} directly override the visit method (Non-virtual Interface principle);
+if a pass desires different recursion behaviour, it should set @visit_children@ to false and perform recursive calls manually within previsit or postvisit procedures.
+To enable this option, inherit from the @WithShortCircuiting@ mixin.
+\item
+previsit may mutate the node but \textbf{must not} change the node type or return @nullptr@.
+\item
+postvisit may mutate the node, reconstruct it to a different node type, or delete it by returning @nullptr@.
 \item
 If the previsit or postvisit method is not defined for a node type, the step is skipped.
 If the return type is declared as void, the original node is returned by default. These
+behaviors are controlled by template specialization rules; see
 @Common/PassVisitor.proto.h@ (old) and @AST/Pass.proto.hpp@ (new) for details.
+If the return type is declared as @void@, the original node is returned by default.
+These behaviours are controlled by template specialization rules;
+see @Common/PassVisitor.proto.h@ (old) and @AST/@ @Pass.proto.hpp@ (new) for details.
 \end{itemize}
 Other useful mixin classes for compilation passes include:
 \begin{itemize}
 \item
+WithGuards allows saving values of variables and restore automatically upon exiting
+the current node.
+\item
+WithVisitorRef creates a wrapped entity of current pass (the actual argument
+passed to recursive calls internally) for explicit recursion, usually used together
+with WithShortCircuiting.
+\item
+WithSymbolTable gives a managed symbol table with built-in scoping rule handling
+(\eg on entering and exiting a block statement)
+@WithGuards@ allows saving and restoring variable values automatically upon entering/exiting the current node.
+\item
+@WithVisitorRef@ creates a wrapped entity for the current pass (the actual argument passed to recursive calls internally) for explicit recursion, usually used together with @WithShortCircuiting@.
+\item
+@WithSymbolTable@ gives a managed symbol table with built-in scoping-rule handling (\eg on entering and exiting a block statement)
 \end{itemize}
+\NOTE: If a pass extends the functionality of another existing pass, due to \CC overloading
+resolution rules, it \textbf{must} explicitly introduce the inherited previsit and postvisit procedures
+to its own scope, or otherwise they will not be picked up by template resolution:
+\NOTE: If a pass extends the functionality of another existing pass, due to \CC overloading resolution rules, it \textbf{must} explicitly introduce the inherited previsit and postvisit procedures to its own scope, or otherwise they are not picked up by template resolution:
 \begin{C++}
 class Pass2: public Pass1 {
         using Pass1::previsit;
         using Pass1::postvisit;
+        @using Pass1::previsit;@
+        @using Pass1::postvisit;@
         // new procedures
+}
 …
+\subsection{Data Structure Change WIP (new-ast)}
+It has been observed that excessive copying of syntax tree structures accounts for a
+majority of computation cost and significantly slows down the compiler. In the previous
+implementation of the syntax tree, every internal node has a unique parent; therefore all
+copies are required to duplicate everything down to the bottom. A new, experimental
+re-implementation of the syntax tree (source under directory AST/ hereby referred to as
+``new-ast'') attempts to overcome this issue with a functional approach that allows sharing
+of common sub-structures and only makes copies when necessary.
+The core of new-ast is a customized implementation of smart pointers, similar to
+@std::shared_ptr@ and @std::weak_ptr@ in \CC standard library. Reference counting is
+used to detect sharing and allows optimization. For a purely functional (a.k.a. immutable)
+data structure, all mutations are modelled by shallow copies along the path of mutation.
+\subsection{Data Structure Change (new-ast)}
+It has been observed that excessive copying of syntax tree structures accounts for a majority of computation cost and significantly slows down the compiler.
+In the previous implementation of the syntax tree, every internal node has a unique parent;
+therefore all copies are required to duplicate the entire subtree.
+A new, experimental re-implementation of the syntax tree (source under directory @AST/@ hereby referred to as ``new-ast'') attempts to overcome this issue with a functional approach that allows sharing of common sub-structures and only makes copies when necessary.
+The core of new-ast is a customized implementation of smart pointers, similar to @std::shared_ptr@ and @std::weak_ptr@ in the \CC standard library.
+Reference counting is used to detect sharing and allowing certain optimizations.
+For a purely functional (immutable) data-structure, all mutations are modelled by shallow copies along the path of mutation.
 With reference counting optimization, unique nodes are allowed to be mutated in place.
+This however, may potentially introduce some complications and bugs; a few issues are
+discussed near the end of this section.
+\subsubsection{Source: AST/Node.hpp}
+class @ast::Node@ is the base class of all new-ast node classes, which implements
+reference counting mechanism. Two different counters are recorded: ``strong'' reference
+count for number of nodes semantically owning it; ``weak'' reference count for number of
+nodes holding a mere reference and only need to observe changes.
+class @ast::ptr_base@ is the smart pointer implementation and also takes care of
+resource management.
+Direct access through the smart pointer is read-only. A mutable access should be obtained
+by calling shallowCopy or mutate as below.
+Currently, the weak pointers are only used to reference declaration nodes from a named
+type, or a variable expression. Since declaration nodes are intended to denote unique
+entities in the program, weak pointers always point to unique (unshared) nodes. This may
+change in the future, and weak references to shared nodes may introduce some problems;
+This however, may potentially introduce some complications and bugs;
+a few issues are discussed near the end of this section.
+\subsubsection{Source: \lstinline{AST/Node.hpp}}
+Class @ast::Node@ is the base class of all new-ast node classes, which implements reference counting mechanism.
+Two different counters are recorded: ``strong'' reference count for number of nodes semantically owning it;
+``weak'' reference count for number of nodes holding a mere reference and only need to observe changes.
+Class @ast::ptr_base@ is the smart pointer implementation and also takes care of resource management.
+Direct access through the smart pointer is read-only.
+A mutable access should be obtained by calling @shallowCopy@ or mutate as below.
+Currently, the weak pointers are only used to reference declaration nodes from a named type, or a variable expression.
+Since declaration nodes are intended to denote unique entities in the program, weak pointers always point to unique (unshared) nodes.
+This property may change in the future, and weak references to shared nodes may introduce some problems;
 see mutate function below.
+All node classes should always use smart pointers in the structure and should not use raw
+pointers.
+All node classes should always use smart pointers in structure definitions versus raw pointers.
+Function
 \begin{C++}
 void ast::Node::increment(ref_type ref)
 \end{C++}
+Increments this node's strong or weak reference count.
+increments this node's strong or weak reference count.
+Function
 \begin{C++}
 void ast::Node::decrement(ref_type ref, bool do_delete = true)
 \end{C++}
+Decrements this node's strong or weak reference count. If strong reference count reaches
+zero, the node is deleted by default.
+\NOTE: Setting @do_delete@ to false may result in a detached node. Subsequent code should
+manually delete the node or assign it to a strong pointer to prevent memory leak.
+decrements this node's strong or weak reference count.
+If strong reference count reaches zero, the node is deleted.
+\NOTE: Setting @do_delete@ to false may result in a detached node.
+Subsequent code should manually delete the node or assign it to a strong pointer to prevent memory leak.
 Reference counting functions are internally called by @ast::ptr_base@.
+Function
 \begin{C++}
 template<typename node_t>
 node_t * shallowCopy(const node_t * node)
 \end{C++}
+Returns a mutable, shallow copy of node: all child pointers are pointing to the same child
+nodes.
+returns a mutable, shallow copy of node: all child pointers are pointing to the same child nodes.
+Function
 \begin{C++}
 template<typename node_t>
 node_t * mutate(const node_t * node)
 \end{C++}
+If node is unique (strong reference count is 1), returns a mutable pointer to the same node.
+Otherwise, returns shallowCopy(node).
+It is an error to mutate a shared node that is weak-referenced. Currently this does not
+happen. The problem may appear once weak pointers to shared nodes (\eg expression
+nodes) are used; special care will be needed.
+\NOTE: This naive uniqueness check may not be sufficient in some cases. A discussion of the
+issue is presented at the end of this section.
+returns a mutable pointer to the same node, if the node is unique (strong reference count is 1);
+otherwise, it returns @shallowCopy(node)@.
+It is an error to mutate a shared node that is weak-referenced.
+Currently this does not happen.
+A problem may appear once weak pointers to shared nodes (\eg expression nodes) are used;
+special care is needed.
+\NOTE: This naive uniqueness check may not be sufficient in some cases.
+A discussion of the issue is presented at the end of this section.
+Functions
 \begin{C++}
 template<typename node_t, typename parent_t, typename field_t, typename assn_t>
 const node_t * mutate_field(const node_t * node, field_t parent_t::*field, assn_t && val)
+const node_t * mutate_field(const node_t * node, field_t parent_t::* field, assn_t && val)
 \end{C++}
 \begin{C++}
 …
                 field_t && val)
 \end{C++}
+Helpers for mutating a field on a node using pointer to member (creates shallow copy
+when necessary).
 \subsubsection{Issue: Undetected sharing}
 The @mutate@ behavior described above has a problem: deeper shared nodes may be
+are helpers for mutating a field on a node using pointer to a member function (creates shallow copy when necessary).
+\subsubsection{Issue: Undetected Sharing}
+The @mutate@ behaviour described above has a problem: deeper shared nodes may be
 mistakenly considered as unique. \VRef[Figure]{f:DeepNodeSharing} shows how the problem could arise:
 \begin{figure}
 …
 \label{f:DeepNodeSharing}
 \end{figure}
+Suppose that we are working on the tree rooted at P1, which
+is logically the chain P1-A-B and P2 is irrelevant, and then
+mutate(B) is called. The algorithm considers B as unique since
+it is only directly owned by A. However, the other tree P2-A-B
+indirectly shares the node B and is therefore wrongly mutated.
+To partly address this problem, if the mutation is called higher up the tree, a chain
+mutation helper can be used:
+\subsubsection{Source: AST/Chain.hpp}
+Given the tree rooted at P1, which is logically the chain P1-A-B, and P2 is irrelevant, assume @mutate(B)@ is called.
+The algorithm considers B as unique since it is only directly owned by A.
+However, the other tree P2-A-B indirectly shares the node B and is therefore wrongly mutated.
+To partly address this problem, if the mutation is called higher up the tree, a chain mutation helper can be used.
+\subsubsection{Source: \lstinline{AST/Chain.hpp}}
+Function
 \begin{C++}
 template<typename node_t, Node::ref_type ref_t>
 auto chain_mutate(ptr_base<node_t, ref_t> & base)
 \end{C++}
+This function returns a chain mutator handle which takes pointer-to-member to go down
+the tree while creating shallow copies as necessary; see @struct _chain_mutator@ in the
+source code for details.
+For example, in the above diagram, if mutation of B is wanted while at P1, the call using
+@chain_mutate@ looks like the following:
+returns a chain mutator handle that takes pointer-to-member to go down the tree, while creating shallow copies as necessary;
+see @struct _chain_mutator@ in the source code for details.
+For example, in the above diagram, if mutation of B is wanted while at P1, the call using @chain_mutate@ looks like the following:
 \begin{C++}
 chain_mutate(P1.a)(&A.b) = new_value_of_b;
 \end{C++}
+Note that if some node in chain mutate is shared (therefore shallow copied), it implies that
+every node further down will also be copied, thus correctly executing the functional
+mutation algorithm. This example code creates copies of both A and B and performs
+mutation on the new nodes, so that the other tree P2-A-B is untouched.
+However, if a pass traverses down to node B and performs mutation, for example, in
+@postvisit(B)@, information on sharing higher up is lost. Since the new-ast structure is only in
+experimental use with the resolver algorithm, which mostly rebuilds the tree bottom-up,
+this issue does not actually happen. It should be addressed in the future when other
+compilation passes are migrated to new-ast and many of them contain procedural
+mutations, where it might cause accidental mutations to other logically independent trees
+(\eg common sub-expression) and become a bug.
+\vspace*{20pt} % FIX ME, spacing problem with this heading ???
+\NOTE: if some node in chain mutate is shared (therefore shallow copied), it implies that every node further down is also copied, thus correctly executing the functional mutation algorithm.
+This example code creates copies of both A and B and performs mutation on the new nodes, so that the other tree P2-A-B is untouched.
+However, if a pass traverses down to node B and performs mutation, for example, in @postvisit(B)@, information on sharing higher up is lost.
+Since the new-ast structure is only in experimental use with the resolver algorithm, which mostly rebuilds the tree bottom-up, this issue does not actually happen.
+It should be addressed in the future when other compilation passes are migrated to new-ast and many of them contain procedural mutations, where it might cause accidental mutations to other logically independent trees (\eg common sub-expression) and become a bug.
 \section{Compiler Algorithm Documentation}
+This documentation currently covers most of the resolver, data structures used in variable
+and expression resolution, and a few directly related passes. Later passes involving code
+generation is not included yet; documentation for those will be done afterwards.
+This compiler algorithm documentation covers most of the resolver, data structures used in variable and expression resolution, and a few directly related passes.
+Later passes involving code generation are not included yet;
+documentation for those will be done latter.
 \subsection{Symbol Table}
+\NOTE: For historical reasons, the symbol table data structure was called ``indexer'' in the
+old implementation. Hereby we will be using the name SymbolTable everywhere.
+The symbol table stores a mapping from names to declarations and implements a similar
+name space separation rule, and the same scoping rules in standard C.\footnote{ISO/IEC 9899:1999, Sections 6.2.1 and 6.2.3} The difference in
+name space rule is that typedef aliases are no longer considered ordinary identifiers.
+In addition to C tag types (struct, union, enum), \CFA introduces another tag type, trait,
+which is a named collection of assertions.
+\subsubsection{Source: AST/SymbolTable.hpp}
+\subsubsection{Source: SymTab/Indexer.h}
+\NOTE: For historical reasons, the symbol-table data-structure is called @indexer@ in the old implementation.
+Hereby, the name is changed to @SymbolTable@.
+The symbol table stores a mapping from names to declarations, implements a similar name-space separation rule, and provides the same scoping rules as standard C.\footnote{ISO/IEC 9899:1999, Sections 6.2.1 and 6.2.3.}
+The difference in name-space rule is that @typedef@ aliases are no longer considered ordinary identifiers.
+In addition to C tag-types (@struct@, @union@, @enum@), \CFA introduces another tag type, @trait@, which is a named collection of assertions.
+\subsubsection{Source: \lstinline{AST/SymbolTable.hpp}}
+\TODO{Add something here}
+\subsubsection{Source: \lstinline{SymTab/Indexer.h}}
+Function
 \begin{C++}
 SymbolTable::addId(const DeclWithType * decl)
 \end{C++}
+Since \CFA allows overloading of variables and functions, ordinary identifier names need
+to be mangled. The mangling scheme is closely based on the Itanium \CC ABI,\footnote{\url{https://itanium-cxx-abi.github.io/cxx-abi/abi.html}, Section 5.1} while
+making adaptations to \CFA specific features, mainly assertions and overloaded variables
+by type. Naming conflicts are handled by mangled names; lookup by name returns a list of
 declarations with the same literal identifier name.
+provides name mangling of identifiers, since \CFA allows overloading of variables and functions.
+The mangling scheme is closely based on the Itanium \CC ABI,\footnote{\url{https://itanium-cxx-abi.github.io/cxx-abi/abi.html}, Section 5.1} while making adaptations to \CFA specific features, mainly assertions and overloaded variables by type.
+Naming conflicts are handled by mangled names;
+lookup by name returns a list of declarations with the same identifier name.
+Functions
 \begin{C++}
 SymbolTable::addStruct(const StructDecl * decl)
 …
 SymbolTable::addTrait(const TraitDecl * decl)
 \end{C++}
+Adds a tag type declaration to the symbol table.
+add a tag-type declaration to the symbol table.
+Function
 \begin{C++}
 SymbolTable::addType(const NamedTypeDecl * decl)
 \end{C++}
+Adds a typedef alias to the symbol table.
+\textbf{C Incompatibility Note}: Since Cforall allows using struct, union and enum type names
+without the keywords, typedef names and tag type names cannot be disambiguated by
+syntax rules. Currently the compiler puts them together and disallows collision. The
+following program is valid C but not valid Cforall:
+adds a @typedef@ alias to the symbol table.
+\textbf{C Incompatibility Note}: Since \CFA allows using @struct@, @union@ and @enum@ type-names without a prefix keyword, as in \CC, @typedef@ names and tag-type names cannot be disambiguated by syntax rules.
+Currently the compiler puts them together and disallows collision.
+The following program is valid C but invalid \CFA (and \CC):
 \begin{C++}
 struct A {};
+typedef int A; // gcc: ok, cfa: Cannot redefine typedef A
+struct A sa; // C disambiguates via struct prefix
+A ia;
+\end{C++}
+In practices, such usage is extremely rare, and hence, this change (as in \CC) has minimal impact on existing C programs.
+The declaration
+\begin{C++}
+struct A {};
+typedef struct A A; // A is an alias for struct A
+A a;
+struct A b;
+\end{C++}
+is not an error because the alias name is identical to the original.
+Finally, the following program is allowed in \CFA:
+\begin{C++}
 typedef int A;
+// gcc: ok, cfa: Cannot redefine typedef A
+\end{C++}
+In actual practices however, such usage is extremely rare, and typedef struct A A; is
+not considered an error, but silently discarded. Therefore, we expect this change to have
+minimal impact on existing C programs.
+Meanwhile, the following program is allowed in Cforall:
+\begin{C++}
+typedef int A;
+void A();
+void A(); // name mangled
 // gcc: A redeclared as different kind of symbol, cfa: ok
 \end{C++}
+because the function name is mangled.
 \subsection{Type Environment and Unification}
+The core of parametric type resolution algorithm.
+Type Environment organizes type parameters in \textbf{equivalent classes} and maps them to
+actual types. Unification is the algorithm that takes two (possibly parametric) types and
+parameter mappings and attempts to produce a common type by matching the type
+environments.
+The following core ideas underlie the parametric type-resolution algorithm.
+A type environment organizes type parameters into \textbf{equivalent classes} and maps them to actual types.
+Unification is the algorithm that takes two (possibly parametric) types and parameter mappings, and attempts to produce a common type by matching information in the type environments.
 The unification algorithm is recursive in nature and runs in two different modes internally:
 \begin{itemize}
 \item
+\textbf{Exact} unification mode requires equivalent parameters to match perfectly;
+\item
+\textbf{Inexact} unification mode allows equivalent parameters to be converted to a
+common type.
+Exact unification mode requires equivalent parameters to match perfectly.
+\item
+Inexact unification mode allows equivalent parameters to be converted to a common type.
 \end{itemize}
+For a pair of matching parameters (actually, their equivalent classes), if either side is open
+(not bound to a concrete type yet), they are simply combined.
+Within inexact mode, types are allowed to differ on their cv-qualifiers; additionally, if a
+type never appear either in parameter list or as the base type of a pointer, it may also be
+widened (i.e. safely converted). As Cforall currently does not implement subclassing similar
+to object-oriented languages, widening conversions are on primitive types only, for
+example the conversion from int to long.
+The need for two unification modes come from the fact that parametric types are
+considered compatible only if all parameters are exactly the same (not just compatible).
+Pointer types also behaves similarly; in fact, they may be viewed as a primitive kind of
+parametric types. @int*@ and @long*@ are different types, just like @vector(int)@ and
+@vector(long)@ are, for the parametric type @vector(T)@.
+The resolver should use the following ``@public@'' functions:\footnote{
+Actual code also tracks assertions on type parameters; those extra arguments are omitted here for
+conciseness.}
+\subsubsection{Source: ResolvExpr/Unify.cc}
+\begin{C++}
+bool unify(const Type *type1, const Type *type2, TypeEnvironment &env,
+OpenVarSet &openVars, const SymbolTable &symtab, Type *&commonType)
+\end{C++}
+Attempts to unify @type1@ and @type2@ with current type environment.
+If operation succeeds, @env@ is modified by combining the equivalence classes of matching
+parameters in @type1@ and @type2@, and their common type is written to commonType.
+If operation fails, returns false.
+\begin{C++}
+bool typesCompatible(const Type * type1, const Type * type2, const
+SymbolTable &symtab, const TypeEnvironment &env)
+bool typesCompatibleIgnoreQualifiers(const Type * type1, const Type *
+type2, const SymbolTable &symtab, const TypeEnvironment &env)
+\end{C++}
+Determines if type1 and type2 can possibly be the same type. The second version ignores
+the outermost cv-qualifiers if present.\footnote{
+In const \lstinline@int * const@, only the second \lstinline@const@ is ignored.}
+The call has no side effect.
+\NOTE: No attempts are made to widen the types (exact unification is used), although the
+function names may suggest otherwise. E.g. @typesCompatible(int, long)@ returns false.
+For a pair of matching parameters (actually, their equivalent classes), if either side is open (not bound to a concrete type yet), they are combined.
+Within the inexact mode, types are allowed to differ on their cv-qualifiers (\eg @const@, @volatile@, \etc);
+additionally, if a type never appear either in a parameter list or as the base type of a pointer, it may also be widened (\ie safely converted).
+As \CFA currently does not implement subclassing as in object-oriented languages, widening conversions are only on the primitive types, \eg conversion from @int@ to @long int@.
+The need for two unification modes comes from the fact that parametric types are considered compatible only if all parameters are exactly the same (not just compatible).
+Pointer types also behaves similarly;
+in fact, they may be viewed as a primitive kind of parametric types.
+@int *@ and @long *@ are different types, just like @vector(int)@ and @vector(long)@ are, for the parametric type @*(T)@ / @vector(T)@, respectively.
+The resolver uses the following @public@ functions:\footnote{
+Actual code also tracks assertions on type parameters; those extra arguments are omitted here for conciseness.}
+\subsubsection{Source: \lstinline{ResolvExpr/Unify.cc}}
+Function
+\begin{C++}
+bool unify(const Type * type1, const Type * type2, TypeEnvironment & env,
+        OpenVarSet & openVars, const SymbolTable & symtab, Type *& commonType)
+\end{C++}
+returns a boolean indicating if the unification succeeds or fails after attempting to unify @type1@ and @type2@ within current type environment.
+If the unify succeeds, @env@ is modified by combining the equivalence classes of matching parameters in @type1@ and @type2@, and their common type is written to @commonType@.
+If the unify fails, nothing changes.
+Functions
+\begin{C++}
+bool typesCompatible(const Type * type1, const Type * type2, const SymbolTable & symtab,
+        const TypeEnvironment & env)
+bool typesCompatibleIgnoreQualifiers(const Type * type1, const Type * type2,
+        const SymbolTable & symtab, const TypeEnvironment & env)
+\end{C++}
+return a boolean indicating if types @type1@ and @type2@ can possibly be the same type.
+The second version ignores the outermost cv-qualifiers if present.\footnote{
+In \lstinline@const int * const@, only the second \lstinline@const@ is ignored.}
+These function have no side effects.
+\NOTE: No attempt is made to widen the types (exact unification is used), although the function names may suggest otherwise, \eg @typesCompatible(int, long)@ returns false.
 \subsection{Expression Resolution}
+The design of the current version of expression resolver is outlined in the Ph.D. Thesis from
+Aaron Moss~\cite{Moss19}.
+The design of the current version of expression resolver is outlined in the Ph.D.\ thesis by Aaron Moss~\cite{Moss19}.
 A summary of the resolver algorithm for each expression type is presented below.
 All overloadable operators are modelled as function calls. For a function call,
+interpretations of the function and arguments are found recursively. Then the following
 steps produce a filtered list of valid interpretations:
+All overloadable operators are modelled as function calls.
+For a function call, interpretations of the function and arguments are found recursively.
+Then the following steps produce a filtered list of valid interpretations:
 \begin{enumerate}
 \item
+From all possible combinations of interpretations of the function and arguments,
+those where argument types may be converted to function parameter types are
+considered valid.
+From all possible combinations of interpretations of the function and arguments, those where argument types may be converted to function parameter types are considered valid.
 \item
 Valid interpretations with the minimum sum of argument costs are kept.
 \item
+Argument costs are then discarded; the actual cost for the function call expression is
+the sum of conversion costs from the argument types to parameter types.
+\item
+For each return type, the interpretations with satisfiable assertions are then sorted
+by actual cost computed in step 3. If for a given type, the minimum cost
+interpretations are not unique, it is said that for that return type the interpretation
+is ambiguous. If the minimum cost interpretation is unique but contains an
+ambiguous argument, it is also considered ambiguous.
+\label{p:argcost}
+Argument costs are then discarded; the actual cost for the function call expression is the sum of conversion costs from the argument types to parameter types.
+\item
+\label{p:returntype}
+For each return type, the interpretations with satisfiable assertions are then sorted by actual cost computed in step~\ref{p:argcost}.
+If for a given type, the minimum cost interpretations are not unique, that return type is ambiguous.
+If the minimum cost interpretation is unique but contains an ambiguous argument, it is also ambiguous.
 \end{enumerate}
 Therefore, for each return type, the resolver produces either of:
+Therefore, for each return type, the resolver produces:
 \begin{itemize}
 \item
 No alternatives
 \item
 A single valid alternative
 \item
 An ambiguous alternative
+no alternatives
+\item
+a single valid alternative
+\item
+an ambiguous alternative
 \end{itemize}
+Note that an ambiguous alternative may be discarded at the parent expressions because a
+different return type matches better for the parent expressions.
+The non-overloadable expressions in Cforall are: cast expressions, address-of (unary @&@)
+expressions, short-circuiting logical expressions (@&&@, @||@) and ternary conditional
+expression (@?:@).
+For a cast expression, the convertible argument types are kept. Then the result is selected
+by lowest argument cost, and further by lowest conversion cost to target type. If the lowest
+cost is still not unique, or an ambiguous argument interpretation is selected, the cast
+expression is ambiguous. In an expression statement, the top level expression is implicitly
+cast to void.
+\NOTE: an ambiguous alternative may be discarded at the parent expressions because a different return type matches better for the parent expressions.
+The \emph{non}-overloadable expressions in \CFA are: cast expressions, address-of (unary @&@) expressions, short-circuiting logical expressions (@&&@, @||@) and ternary conditional expression (@?:@).
+For a cast expression, the convertible argument types are kept.
+Then the result is selected by lowest argument cost, and further by lowest conversion cost to target type.
+If the lowest cost is still not unique or an ambiguous argument interpretation is selected, the cast expression is ambiguous.
+In an expression statement, the top level expression is implicitly cast to @void@.
 For an address-of expression, only lvalue results are kept and the minimum cost is selected.
+For logical expressions @&&@ and @||@, arguments are implicitly cast to bool, and follow the rule
+of cast expression as above.
+For the ternary conditional expression, the condition is implicitly cast to bool, and the
+branch expressions must have compatible types. Each pair of compatible branch
+expression types produce a possible interpretation, and the cost is defined as the sum of
+expression costs plus the sum of conversion costs to the common type.
+TODO: Write a specification for expression costs.
+For logical expressions @&&@ and @||@, arguments are implicitly cast to @bool@, and follow the rules fr cast expression above.
+For the ternary conditional expression, the condition is implicitly cast to @bool@, and the branch expressions must have compatible types.
+Each pair of compatible branch expression types produce a possible interpretation, and the cost is defined as the sum of the expression costs plus the sum of conversion costs to the common type.
+\TODO{Write a specification for expression costs.}
 \subsection{Assertion Satisfaction}
+The resolver tries to satisfy assertions on expressions only when it is needed: either while
+selecting from multiple alternatives of a same result type for a function call (step 4 of
+resolving function calls), or upon reaching the top level of an expression statement.
+Unsatisfiable alternatives are discarded. Satisfiable alternatives receive \textbf{implicit
+parameters}: in Cforall, parametric functions are designed such that they can be compiled
+separately, as opposed to \CC templates which are only compiled at instantiation. Given a
+parametric function definition:
+The resolver tries to satisfy assertions on expressions only when it is needed: either while selecting from multiple alternatives of a same result type for a function call (step \ref{p:returntype} of resolving function calls) or upon reaching the top level of an expression statement.
+Unsatisfiable alternatives are discarded.
+Satisfiable alternatives receive \textbf{implicit parameters}: in \CFA, parametric functions may be separately compiled, as opposed to \CC templates which are only compiled at instantiation.
+Given the parametric function-definition:
 \begin{C++}
 forall (otype T | {void foo(T);})
 void bar (T t) { foo(t); }
 \end{C++}
+The function bar does not know which @foo@ to call when compiled without knowing the call
+site, so it requests a function pointer to be passed as an extra argument. At the call site,
+implicit parameters are automatically inserted by the compiler.
+\textbf{TODO}: Explain how recursive assertion satisfaction and polymorphic recursion work.
+the function @bar@ does not know which @foo@ to call when compiled without knowing the call site, so it requests a function pointer to be passed as an extra argument.
+At the call site, implicit parameters are automatically inserted by the compiler.
+\TODO{Explain how recursive assertion satisfaction and polymorphic recursion work.}
 …
 \subsection{Test Suites}
+Automatic test suites are located under the @tests/@ directory. A test case consists of an
+input CFA source file (name ending with @.cfa@), and an expected output file located
+in @.expect/@ directory relative to the source file, with the same file name ending with @.txt@.
+So a test named @tuple/tupleCast@ has the following files, for example:
+Automatic test suites are located under the @tests/@ directory.
+A test case consists of an input CFA source file (suffix @.cfa@), and an expected output file located in the @tests/.expect/@ directory, with the same file name ending with suffix @.txt@.
+For example, the test named @tests/tuple/tupleCast.cfa@ has the following files, for example:
 \begin{C++}
 tests/
+..     tuple/
+......     .expect/
+..........       tupleCast.txt
+......     tupleCast.cfa
+\end{C++}
+If compilation fails, the error output is compared to the expect file. If compilation succeeds,
+the built program is run and its output compared to the expect file.
+To run the tests, execute the test script @test.py@ under the @tests/@ directory, with a list of
+test names to be run, or @--all@ to run all tests. The test script reports test cases
+fail/success, compilation time and program run time.
+        tuple/
+                .expect/
+                        tupleCast.txt
+                tupleCast.cfa
+\end{C++}
+If compilation fails, the error output is compared to the expect file.
+If the compilation succeeds but does not generate an executable, the compilation output is compared to the expect file.
+If the compilation succeeds and generates an executable, the executable is run and its output is compared to the expect file.
+To run the tests, execute the test script @test.py@ under the @tests/@ directory, with a list of test names to be run, or @--all@ (or @make all-tests@) to run all tests.
+The test script reports test cases fail/success, compilation time and program run time.
+To see all the options available for @test.py@ using the @--help@ option.
 \subsection{Performance Reports}
+To turn on performance reports, pass @-S@ flag to the compiler.
+kinds of performance reports are available:
+To turn on performance reports, pass the @-XCFA -S@ flag to the compiler.
+Three kinds of performance reports are available:
 \begin{enumerate}
 \item
 …
 @Common/Stats/Counter.h@.
 \end{enumerate}
 It is suggested to run performance tests with optimized build (@g++@ flag @-O3@)
+It is suggested to run performance tests with optimization (@g++@ flag @-O3@).

doc/user/user.tex

-                      r91fb850
+                      rc7806122
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Fri Mar  6 13:34:52 2020
 %% Update Count     : 3924
+%% Last Modified On : Thu Sep 24 16:34:52 2020
+%% Update Count     : 3997
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{upquote}                                                                    % switch curled `'" to straight
 \usepackage{calc}
-\usepackage{xspace}
 \usepackage{varioref}                                                                   % extended references
+\usepackage{listings}                                                                   % format program code
+\usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt]{subfig}
+\renewcommand{\thesubfigure}{\alph{subfigure})}
 \usepackage[flushmargin]{footmisc}                                              % support label/reference in footnote
 \usepackage{latexsym}                                   % \Box glyph
 \usepackage{mathptmx}                                   % better math font with "times"
 \usepackage[usenames]{color}
+\input{common}                                          % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\CFAStyle                                                                                               % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
+{}
+\newcommand{\CFALatin}{}
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 …
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
+\input{common}                                          % common CFA document macros
+\usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
+\usepackage{breakurl}
+\renewcommand\footnoterule{\kern -3pt\rule{0.3\linewidth}{0.15pt}\kern 2pt}
+\usepackage[pagewise]{lineno}
+\renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage[firstpage]{draftwatermark}
+\SetWatermarkLightness{0.9}
+% Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
+% removes it as a variable-name character so keywords in variables are highlighted. MUST APPEAR
+% AFTER HYPERREF.
+\renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
+\setlength{\topmargin}{-0.45in}                                                 % move running title into header
+\setlength{\headsep}{0.25in}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\CFADefaults                                                                                    % use default CFA format-style
+\lstnewenvironment{C++}[1][]                            % use C++ style
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
+{}
+\newsavebox{\myboxA}
+\newsavebox{\myboxB}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 \newcommand{\KWC}{K-W C\xspace}
-\newsavebox{\LstBox}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{lstlisting}
+\begin{cfa}
 ®forall( otype T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); §\C{// T is bound to int, forty\_two == 42}§
 \end{lstlisting}
+\end{cfa}
 % extending the C type system with parametric polymorphism and overloading, as opposed to the \Index*[C++]{\CC{}} approach of object-oriented extensions.
 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \Index*{Glen Ditchfield}\index{Ditchfield, Glen}~\cite{Ditchfield92}, and first implemented by \Index*{Richard Bilson}\index{Bilson, Richard}~\cite{Bilson03}.
 …
 \begin{comment}
 A simple example is leveraging the existing type-unsafe (©void *©) C ©bsearch© to binary search a sorted floating array:
 \begin{lstlisting}
+\begin{cfa}
 void * bsearch( const void * key, const void * base, size_t dim, size_t size,
                                 int (* compar)( const void *, const void * ));
 …
 double key = 5.0, vals[10] = { /* 10 sorted floating values */ };
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); §\C{// search sorted array}§
 \end{lstlisting}
+\end{cfa}
 which can be augmented simply with a polymorphic, type-safe, \CFA-overloaded wrappers:
 \begin{lstlisting}
+\begin{cfa}
 forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
         int comp( const void * t1, const void * t2 ) { /* as above with double changed to T */ }
 …
 double * val = bsearch( 5.0, vals, 10 ); §\C{// selection based on return type}§
 int posn = bsearch( 5.0, vals, 10 );
 \end{lstlisting}
+\end{cfa}
 The nested function ©comp© provides the hidden interface from typed \CFA to untyped (©void *©) C, plus the cast of the result.
 Providing a hidden ©comp© function in \CC is awkward as lambdas do not use C calling-conventions and template declarations cannot appear at block scope.
 …
 \CFA has replacement libraries condensing hundreds of existing C functions into tens of \CFA overloaded functions, all without rewriting the actual computations.
 For example, it is possible to write a type-safe \CFA wrapper ©malloc© based on the C ©malloc©:
 \begin{lstlisting}
+\begin{cfa}
 forall( dtype T | sized(T) ) T * malloc( void ) { return (T *)malloc( sizeof(T) ); }
 int * ip = malloc(); §\C{// select type and size from left-hand side}§
 double * dp = malloc();
 struct S {...} * sp = malloc();
 \end{lstlisting}
+\end{cfa}
 where the return type supplies the type/size of the allocation, which is impossible in most type systems.
 \end{comment}
 …
 the same level as a ©case© clause; the target label may be case ©default©, but only associated
 with the current ©switch©/©choose© statement.
-\subsection{Loop Control}
-The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
-\begin{itemize}
-\item
-The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
-\item
-An empty conditional implies comparison value of ©1© (true).
-\item
-A comparison N is implicit up-to exclusive range [0,N©®)®©.
-\item
-A comparison ©=© N is implicit up-to inclusive range [0,N©®]®©.
-\item
-The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©.
-\item
-The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©.
-\item
-The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M©®)®©.
-\item
-The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M©®]®©.
-\item
-©0© is the implicit start value;
-\item
-©1© is the implicit increment value.
-\item
-The up-to range uses operator ©+=© for increment;
-\item
-The down-to range uses operator ©-=© for decrement.
-\item
-©@© means put nothing in this field.
-\item
-©:© means start another index.
-\end{itemize}
 \begin{figure}
 …
+\subsection{Loop Control}
+The ©for©/©while©/©do-while© loop-control allows empty or simplified ranges (see Figure~\ref{f:LoopControlExamples}).
+\begin{itemize}
+\item
+The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
+\item
+An empty conditional implies comparison value of ©1© (true).
+\item
+A comparison N is implicit up-to exclusive range [0,N©®)®©.
+\item
+A comparison ©=© N is implicit up-to inclusive range [0,N©®]®©.
+\item
+The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N©®)®©.
+\item
+The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N©®]®©.
+\item
+The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M©®)®©.
+\item
+The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M©®]®©.
+\item
+©0© is the implicit start value;
+\item
+©1© is the implicit increment value.
+\item
+The up-to range uses operator ©+=© for increment;
+\item
+The down-to range uses operator ©-=© for decrement.
+\item
+©@© means put nothing in this field.
+\item
+©:© means start another index.
+\end{itemize}
 %\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 …
 for ©break©, the target label can also be associated with a ©switch©, ©if© or compound (©{}©) statement.
 \VRef[Figure]{f:MultiLevelExit} shows ©continue© and ©break© indicating the specific control structure, and the corresponding C program using only ©goto© and labels.
 The innermost loop has 7 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
+The innermost loop has 8 exit points, which cause continuation or termination of one or more of the 7 \Index{nested control-structure}s.
 \begin{figure}
+\begin{tabular}{@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\multicolumn{1}{@{\hspace{\parindentlnth}}c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}   & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\begin{cfa}
+®LC:® {
+        ... §declarations§ ...
+        ®LS:® switch ( ... ) {
+          case 3:
+                ®LIF:® if ( ... ) {
+                        ®LF:® for ( ... ) {
+                                ®LW:® while ( ... ) {
+                                        ... break ®LC®; ...
+                                        ... break ®LS®; ...
+                                        ... break ®LIF®; ...
+                                        ... continue ®LF;® ...
+                                        ... break ®LF®; ...
+                                        ... continue ®LW®; ...
+                                        ... break ®LW®; ...
+                                } // while
+                        } // for
+                } else {
+                        ... break ®LIF®; ...
+                } // if
+        } // switch
+\centering
+\begin{lrbox}{\myboxA}
+\begin{cfa}[tabsize=3]
+®Compound:® {
+        ®Try:® try {
+                ®For:® for ( ... ) {
+                        ®While:® while ( ... ) {
+                                ®Do:® do {
+                                        ®If:® if ( ... ) {
+                                                ®Switch:® switch ( ... ) {
+                                                        case 3:
+                                                                ®break Compound®;
+                                                                ®break Try®;
+                                                                ®break For®;      /* or */  ®continue For®;
+                                                                ®break While®;  /* or */  ®continue While®;
+                                                                ®break Do®;      /* or */  ®continue Do®;
+                                                                ®break If®;
+                                                                ®break Switch®;
+                                                        } // switch
+                                                } else {
+                                                        ... ®break If®; ...     // terminate if
+                                                } // if
+                                } while ( ... ); // do
+                        } // while
+                } // for
+        } ®finally® { // always executed
+        } // try
 } // compound
 \end{cfa}
+&
+\begin{cfa}
+\end{lrbox}
+\begin{lrbox}{\myboxB}
+\begin{cfa}[tabsize=3]
+{
+        ... §declarations§ ...
+        switch ( ... ) {
+          case 3:
+                if ( ... ) {
+                        for ( ... ) {
+                                while ( ... ) {
+                                        ... goto ®LC®; ...
+                                        ... goto ®LS®; ...
+                                        ... goto ®LIF®; ...
+                                        ... goto ®LFC®; ...
+                                        ... goto ®LFB®; ...
+                                        ... goto ®LWC®; ...
+                                        ... goto ®LWB®; ...
+                                  ®LWC®: ; } ®LWB:® ;
+                          ®LFC:® ; } ®LFB:® ;
+                } else {
+                        ... goto ®LIF®; ...
+                } ®L3:® ;
+        } ®LS:® ;
+} ®LC:® ;
+\end{cfa}
+&
+\begin{cfa}
+// terminate compound
+// terminate switch
+// terminate if
+// continue loop
+// terminate loop
+// continue loop
+// terminate loop
+// terminate if
+\end{cfa}
+\end{tabular}
+                ®ForC:® for ( ... ) {
+                        ®WhileC:® while ( ... ) {
+                                ®DoC:® do {
+                                        if ( ... ) {
+                                                switch ( ... ) {
+                                                        case 3:
+                                                                ®goto Compound®;
+                                                                ®goto Try®;
+                                                                ®goto ForB®;      /* or */  ®goto ForC®;
+                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
+                                                                ®goto DoB®;      /* or */  ®goto DoC®;
+                                                                ®goto If®;
+                                                                ®goto Switch®;
+                                                        } ®Switch:® ;
+                                                } else {
+                                                        ... ®goto If®; ...      // terminate if
+                                                } ®If:®;
+                                } while ( ... ); ®DoB:® ;
+                        } ®WhileB:® ;
+                } ®ForB:® ;
+} ®Compound:® ;
+\end{cfa}
+\end{lrbox}
+\subfloat[\CFA]{\label{f:CFibonacci}\usebox\myboxA}
+\hspace{2pt}
+\vrule
+\hspace{2pt}
+\subfloat[C]{\label{f:CFAFibonacciGen}\usebox\myboxB}
 \caption{Multi-level Exit}
 \label{f:MultiLevelExit}
 …
 try {
         f(...);
 } catch( E e ; §boolean-predicate§ ) {          §\C[8cm]{// termination handler}§
+} catch( E e ; §boolean-predicate§ ) {          §\C{// termination handler}§
         // recover and continue
 } catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}\CRT§
+} catchResume( E e ; §boolean-predicate§ ) { §\C{// resumption handler}§
         // repair and return
 } finally {
 …
 For implicit formatted input, the common case is reading a sequence of values separated by whitespace, where the type of an input constant must match with the type of the input variable.
 \begin{cquote}
 \begin{lrbox}{\LstBox}
+\begin{lrbox}{\myboxA}
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 int x;   double y   char z;
 …
 \end{lrbox}
 \begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{3em}}l@{}}
 \multicolumn{1}{@{}l@{}}{\usebox\LstBox} \\
+\multicolumn{1}{@{}l@{}}{\usebox\myboxA} \\
 \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{\CC}}       & \multicolumn{1}{c}{\textbf{Python}}   \\
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 …
 For example, an initial alignment and fill capability are preserved during a resize copy so the copy has the same alignment and extended storage is filled.
 Without sticky properties it is dangerous to use ©realloc©, resulting in an idiom of manually performing the reallocation to maintain correctness.
+\begin{cfa}
+\end{cfa}
 \CFA memory management extends allocation to support constructors for initialization of allocated storage, \eg in
 …
         // §\CFA§ safe general allocation, fill, resize, alignment, array
+        T * alloc( void );§\indexc{alloc}§
+        T * alloc( size_t dim );
+        T * alloc( T ptr[], size_t dim );
+        T * alloc_set( char fill );§\indexc{alloc_set}§
+        T * alloc_set( T fill );
+        T * alloc_set( size_t dim, char fill );
+        T * alloc_set( size_t dim, T fill );
+        T * alloc_set( size_t dim, const T fill[] );
+        T * alloc_set( T ptr[], size_t dim, char fill );
+        T * alloc_align( size_t align );
+        T * alloc_align( size_t align, size_t dim );
+        T * alloc_align( T ptr[], size_t align ); // aligned realloc array
+        T * alloc_align( T ptr[], size_t align, size_t dim ); // aligned realloc array
+        T * alloc_align_set( size_t align, char fill );
+        T * alloc_align_set( size_t align, T fill );
+        T * alloc_align_set( size_t align, size_t dim, char fill );
+        T * alloc_align_set( size_t align, size_t dim, T fill );
+        T * alloc_align_set( size_t align, size_t dim, const T fill[] );
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill );
+        T * alloc( void );§\indexc{alloc}§                                      §\C[3.5in]{// variable, T size}§
+        T * alloc( size_t dim );                                                        §\C{// array[dim], T size elements}§
+        T * alloc( T ptr[], size_t dim );                                       §\C{// realloc array[dim], T size elements}§
+        T * alloc_set( char fill );§\indexc{alloc_set}§         §\C{// variable, T size, fill bytes with value}§
+        T * alloc_set( T fill );                                                        §\C{// variable, T size, fill with value}§
+        T * alloc_set( size_t dim, char fill );                         §\C{// array[dim], T size elements, fill bytes with value}§
+        T * alloc_set( size_t dim, T fill );                            §\C{// array[dim], T size elements, fill elements with value}§
+        T * alloc_set( size_t dim, const T fill[] );            §\C{// array[dim], T size elements, fill elements with array}§
+        T * alloc_set( T ptr[], size_t dim, char fill );        §\C{// realloc array[dim], T size elements, fill bytes with value}§
+        T * alloc_align( size_t align );                                        §\C{// aligned variable, T size}§
+        T * alloc_align( size_t align, size_t dim );            §\C{// aligned array[dim], T size elements}§
+        T * alloc_align( T ptr[], size_t align );                       §\C{// realloc new aligned array}§
+        T * alloc_align( T ptr[], size_t align, size_t dim ); §\C{// realloc new aligned array[dim]}§
+        T * alloc_align_set( size_t align, char fill );         §\C{// aligned variable, T size, fill bytes with value}§
+        T * alloc_align_set( size_t align, T fill );            §\C{// aligned variable, T size, fill with value}§
+        T * alloc_align_set( size_t align, size_t dim, char fill ); §\C{// aligned array[dim], T size elements, fill bytes with value}§
+        T * alloc_align_set( size_t align, size_t dim, T fill ); §\C{// aligned array[dim], T size elements, fill elements with value}§
+        T * alloc_align_set( size_t align, size_t dim, const T fill[] ); §\C{// aligned array[dim], T size elements, fill elements with array}§
+        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); §\C{// realloc new aligned array[dim], fill new bytes with value}§
         // §\CFA§ safe initialization/copy, i.e., implicit size specification

src/AST/Convert.cpp

-                      r91fb850
+                      rc7806122
         const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
                 if ( inCache( node ) ) return nullptr;
+                // function decl contains real variables that the type must use.
+                // the structural change means function type in and out of decl
+                // must be handled **differently** on convert back to old.
+                auto ftype = new FunctionType(
+                        cv(node->type),
+                        (bool)node->type->isVarArgs
+                );
+                ftype->returnVals = get<DeclarationWithType>().acceptL(node->returns);
+                ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
+                visitType(node->type, ftype);
                 auto decl = new FunctionDecl(
                         node->name,
                         Type::StorageClasses( node->storage.val ),
                         LinkageSpec::Spec( node->linkage.val ),
+                        get<FunctionType>().accept1( node->type ),
+                        ftype,
+                        //get<FunctionType>().accept1( node->type ),
                         {},
                         get<Attribute>().acceptL( node->attributes ),
 …
         const ast::Type * visit( const ast::FunctionType * node ) override final {
+                static std::string dummy_paramvar_prefix = "__param_";
+                static std::string dummy_returnvar_prefix = "__retval_";
                 auto ty = new FunctionType {
                         cv( node ),
                         (bool)node->isVarArgs
                 };
+                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
+                auto returns = get<Type>().acceptL(node->returns);
+                auto params = get<Type>().acceptL(node->params);
+                int ret_index = 0;
+                for (auto t: returns) {
+                        // xxx - LinkageSpec shouldn't matter but needs to be something
+                        ObjectDecl * dummy = new ObjectDecl(dummy_returnvar_prefix + std::to_string(ret_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->returnVals.push_back(dummy);
+                }
+                int param_index = 0;
+                for (auto t: params) {
+                        ObjectDecl * dummy = new ObjectDecl(dummy_paramvar_prefix + std::to_string(param_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->parameters.push_back(dummy);
+                }
+                // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
 …
         ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
+        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
+        /// in case that some nodes are dropped by conversion (due to possible structural change)
+        /// use smart pointers in cache value to prevent accidental invalidation.
+        /// at conversion stage, all created nodes are guaranteed to be unique, therefore
+        /// const_casting out of smart pointers is permitted.
+        std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
         // Local Utilities:
 …
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
                 node = it->second;
+                node = const_cast<ast::Node *>(it->second.get());
                 return true;
+        }
 …
         virtual void visit( const FunctionDecl * old ) override final {
                 if ( inCache( old ) ) return;
+                auto paramVars = GET_ACCEPT_V(type->parameters, DeclWithType);
+                auto returnVars = GET_ACCEPT_V(type->returnVals, DeclWithType);
+                auto forall = GET_ACCEPT_V(type->forall, TypeDecl);
+                // 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());
+                ftype->returns.reserve(returnVars.size());
+                for (auto & v: paramVars) {
+                        ftype->params.emplace_back(v->get_type());
+                }
+                for (auto & v: returnVars) {
+                        ftype->returns.emplace_back(v->get_type());
+                }
+                ftype->forall = std::move(forall);
+                visitType(old->type, ftype);
                 auto decl = new ast::FunctionDecl{
                         old->location,
                         old->name,
+                        GET_ACCEPT_1(type, FunctionType),
+                        // GET_ACCEPT_1(type, FunctionType),
+                        std::move(paramVars),
+                        std::move(returnVars),
                         {},
                         { old->storageClasses.val },
 …
                         { old->get_funcSpec().val }
                 };
+                decl->type = ftype;
                 cache.emplace( old, decl );
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
 …
                         cv( old )
                 };
+                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                auto returnVars = GET_ACCEPT_V(returnVals, DeclWithType);
+                auto paramVars = GET_ACCEPT_V(parameters, DeclWithType);
+                // ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                // ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                for (auto & v: returnVars) {
+                        ty->returns.emplace_back(v->get_type());
+                }
+                for (auto & v: paramVars) {
+                        ty->params.emplace_back(v->get_type());
+                }
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );

src/AST/Decl.hpp

-                      r91fb850
+                      rc7806122
 class FunctionDecl : public DeclWithType {
 public:
+        std::vector<ptr<DeclWithType>> params;
+        std::vector<ptr<DeclWithType>> returns;
+        // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
+        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
+        FunctionDecl( const CodeLocation & loc, const std::string & name,
+                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 ), type( type ),
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
           stmts( stmts ) {}

src/AST/ForallSubstitutor.hpp

-                      r91fb850
+                      rc7806122
+        }
+        template<typename node_t >
+        std::vector<ptr<node_t>> operator() (const std::vector<ptr<node_t>> & o) {
+                std::vector<ptr<node_t>> n;
+                n.reserve(o.size());
+                for (const node_t * d : o) { n.emplace_back(d->accept(*visitor)); }
+                return n;
+        }
+        /*
         /// Substitute parameter/return type
         std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) {
 …
                 return n;
+        }
+        */
 };

src/AST/Pass.impl.hpp

-                      r91fb850
+                      rc7806122
                         __pass::symtab::addId( core, 0, func );
                         VISIT(
+                                // parameter declarations are now directly here
+                                maybe_accept( node, &FunctionDecl::params );
+                                maybe_accept( node, &FunctionDecl::returns );
+                                // 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

src/AST/SymbolTable.cpp

-                      r91fb850
+                      rc7806122
+}
+/*
 void SymbolTable::addFunctionType( const FunctionType * ftype ) {
         addTypes( ftype->forall );
 …
         addIds( ftype->params );
+}
+*/
 void SymbolTable::lazyInitScope() {
 …
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
                 const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                const Type * base = InitTweak::getPointerBase( params.front() );
                 assert( base );
                 return Mangle::mangle( base );

src/AST/SymbolTable.hpp

r91fb850	rc7806122
145	145
146	146	/// convenience function for adding all of the declarations in a function type to the indexer
147		void addFunctionType( const FunctionType * ftype );
	147	// void addFunctionType( const FunctionType * ftype );
148	148
149	149	private:

src/AST/Type.cpp

-                      r91fb850
+                      rc7806122
 // --- FunctionType
 FunctionType::FunctionType( const FunctionType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
 …
 namespace {
         bool containsTtype( const std::vector<ptr<DeclWithType>> & l ) {
+        bool containsTtype( const std::vector<ptr<Type>> & l ) {
                 if ( ! l.empty() ) {
                         return Tuples::isTtype( l.back()->get_type() );
+                        return Tuples::isTtype( l.back() );
+                }
                 return false;

src/AST/Type.hpp

-                      r91fb850
+                      rc7806122
 class FunctionType final : public ParameterizedType {
 public:
+        std::vector<ptr<DeclWithType>> returns;
+        std::vector<ptr<DeclWithType>> params;
+//      std::vector<ptr<DeclWithType>> returns;
+//      std::vector<ptr<DeclWithType>> params;
+        std::vector<ptr<Type>> returns;
+        std::vector<ptr<Type>> params;
         /// Does the function accept a variable number of arguments following the arguments specified

src/InitTweak/InitTweak.cc

-                      r91fb850
+                      rc7806122
                 if ( ftype->params.size() != 2 ) return false;
                 const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
+                const ast::Type * t1 = getPointerBase( ftype->params.front() );
                 if ( ! t1 ) return false;
                 const ast::Type * t2 = ftype->params.back()->get_type();
+                const ast::Type * t2 = ftype->params.back();
                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );

src/ResolvExpr/CandidateFinder.cpp

-                      r91fb850
+                      rc7806122
                         // mark conversion cost and also specialization cost of param type
                         const ast::Type * paramType = (*param)->get_type();
+                        // const ast::Type * paramType = (*param)->get_type();
                         cand->expr = ast::mutate_field_index(
                                 appExpr, &ast::ApplicationExpr::args, i,
                                 computeExpressionConversionCost(
                                         args[i], paramType, symtab, cand->env, convCost ) );
                         convCost.decSpec( specCost( paramType ) );
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
                         ++param;  // can't be in for-loop update because of the continue
+                }
 …
                         if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
                                 // attempt to narrow based on expected target type
                                 const ast::Type * returnType = funcType->returns.front()->get_type();
+                                const ast::Type * returnType = funcType->returns.front();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
 …
                         std::size_t genStart = 0;
+                        for ( const ast::DeclWithType * param : funcType->params ) {
+                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
+                        // xxx - how to handle default arg after change to ftype representation?
+                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                        // function may have default args only if directly calling by name
+                                        // must use types on candidate however, due to RenameVars substitution
+                                        auto nParams = funcType->params.size();
+                                        for (size_t i=0; i<nParams; ++i) {
+                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                                if (!instantiateArgument(
+                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
+                                        goto endMatch;
+                                }
+                        }
+                        for ( const auto & param : funcType->params ) {
                                 // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
+                                // no default args for indirect calls
                                 if ( ! instantiateArgument(
+                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
+                        }
+                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
+                        endMatch:
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack

src/ResolvExpr/CurrentObject.cc

-                      r91fb850
+                      rc7806122
         class SimpleIterator final : public MemberIterator {
                 CodeLocation location;
                 readonly< Type > type = nullptr;
+                const Type * type = nullptr;
         public:
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
 …
         class ArrayIterator final : public MemberIterator {
                 CodeLocation location;
                 readonly< ArrayType > array = nullptr;
                 readonly< Type > base = nullptr;
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;

src/ResolvExpr/Resolver.cc

-                      r91fb850
+                      rc7806122
                 template<typename Iter>
                 inline bool nextMutex( Iter & it, const Iter & end ) {
                         while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
+                        while ( it != end && ! (*it)->is_mutex() ) { ++it; }
                         return it != end;
+                }
 …
                                                                 // Check if the argument matches the parameter type in the current
                                                                 // scope
                                                                 ast::ptr< ast::Type > paramType = (*param)->get_type();
+                                                                // ast::ptr< ast::Type > paramType = (*param)->get_type();
                                                                 if (
                                                                         ! unify(
                                                                                 arg->expr->result, paramType, resultEnv, need, have, open,
+                                                                                arg->expr->result, *param, resultEnv, need, have, open,
                                                                                 symtab )
                                                                 ) {
 …
                                                                         ss << "candidate function not viable: no known conversion "
                                                                                 "from '";
                                                                         ast::print( ss, (*param)->get_type() );
+                                                                        ast::print( ss, *param );
                                                                         ss << "' to '";
                                                                         ast::print( ss, arg->expr->result );

src/ResolvExpr/SatisfyAssertions.cpp

-                      r91fb850
+                      rc7806122
                                         if ( ! func ) continue;
                                         for ( const ast::DeclWithType * param : func->params ) {
                                                 cost.decSpec( specCost( param->get_type() ) );
+                                        for ( const auto & param : func->params ) {
+                                                cost.decSpec( specCost( param ) );
+                                        }

src/ResolvExpr/SpecCost.cc

-                      r91fb850
+                      rc7806122
                 void previsit( const ast::FunctionType * fty ) {
                         int minCount = std::numeric_limits<int>::max();
                         updateMinimumPresent( minCount, fty->params, decl_type );
                         updateMinimumPresent( minCount, fty->returns, decl_type );
+                        updateMinimumPresent( minCount, fty->params, type_deref );
+                        updateMinimumPresent( minCount, fty->returns, type_deref );
                         // Add another level to minCount if set.
                         count = toNoneOrInc( minCount );

src/ResolvExpr/Unify.cc

-                      r91fb850
+                      rc7806122
         template< typename Iterator1, typename Iterator2 >
         bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
 …
                                         || flatOther->isTtype()
                         ) {
                                 if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
                                         if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
                                                 // the original types must be used in mark assertions, since pointer comparisons are used
 …
                 /// returns flattened version of `src`
                 static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
                         const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
+                static std::vector< ast::ptr< ast::Type > > flattenList(
+                        const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
                 ) {
                         std::vector< ast::ptr< ast::DeclWithType > > dst;
+                        std::vector< ast::ptr< ast::Type > > dst;
                         dst.reserve( src.size() );
                         for ( const ast::DeclWithType * d : src ) {
+                        for ( const auto & d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
                                 // TtypeExpander pass is impure (may mutate nodes in place)
                                 // need to make nodes shared to prevent accidental mutation
                                 ast::ptr<ast::DeclWithType> dc = d->accept(expander);
                                 auto types = flatten( dc->get_type() );
+                                ast::ptr<ast::Type> dc = d->accept(expander);
+                                auto types = flatten( dc );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
 …
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
                                         dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
+                                        dst.emplace_back( t );
+                                }
+                        }
 …
                 /// Creates a tuple type based on a list of DeclWithType
                 template< typename Iter >
                 static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
+                static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
                         std::vector< ast::ptr< ast::Type > > types;
                         while ( crnt != end ) {
                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
                                 // that this results in a flat tuple
                                 flatten( (*crnt)->get_type(), types );
+                                flatten( *crnt, types );
                                 ++crnt;
 …
                 template< typename Iter >
                 static bool unifyDeclList(
+                static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
 …
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
                                 const ast::Type * t1 = (*crnt1)->get_type();
                                 const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t1 = *crnt1;
+                                const ast::Type * t2 = *crnt2;
                                 bool isTuple1 = Tuples::isTtype( t1 );
                                 bool isTuple2 = Tuples::isTtype( t2 );
 …
                                         // combine remainder of list2, then unify
                                         return unifyExact(
                                                 t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                                t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                                 noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
                                                 tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                                tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
+                                }
 …
                         if ( crnt1 != end1 ) {
                                 // try unifying empty tuple with ttype
                                 const ast::Type * t1 = (*crnt1)->get_type();
+                                const ast::Type * t1 = *crnt1;
                                 if ( ! Tuples::isTtype( t1 ) ) return false;
                                 return unifyExact(
                                         t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                        t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                         noWiden(), symtab );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
                                 const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t2 = *crnt2;
                                 if ( ! Tuples::isTtype( t2 ) ) return false;
                                 return unifyExact(
                                         tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                        tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                         noWiden(), symtab );
+                        }
 …
+                }
                 static bool unifyDeclList(
                         const std::vector< ast::ptr< ast::DeclWithType > > & list1,
                         const std::vector< ast::ptr< ast::DeclWithType > > & list2,
+                static bool unifyTypeList(
+                        const std::vector< ast::ptr< ast::Type > > & list1,
+                        const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
                 ) {
                         return unifyDeclList(
+                        return unifyTypeList(
                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
                                 symtab );
 …
                         ) return;
                         if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
                         if ( ! unifyDeclList(
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList(
                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
 …
         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
                 if ( func->returns.empty() ) return new ast::VoidType{};
                 if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+                if ( func->returns.size() == 1 ) return func->returns[0];
                 std::vector<ast::ptr<ast::Type>> tys;
                 for ( const ast::DeclWithType * decl : func->returns ) {
                         tys.emplace_back( decl->get_type() );
+                for ( const auto & decl : func->returns ) {
+                        tys.emplace_back( decl );
+                }
                 return new ast::TupleType{ std::move(tys) };

src/SymTab/Mangler.cc

-                      r91fb850
+                      rc7806122
                         GuardValue( inFunctionType );
                         inFunctionType = true;
+                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
+                        if (returnTypes.empty()) mangleName << Encoding::void_t;
+                        else accept_each( returnTypes, *visitor );
+                        if (functionType->returns.empty()) mangleName << Encoding::void_t;
+                        else accept_each( functionType->returns, *visitor );
                         mangleName << "_";
+                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
+                        accept_each( paramTypes, *visitor );
+                        accept_each( functionType->params, *visitor );
                         mangleName << "_";
+                }

src/SymTab/Validate.cc

-                      r91fb850
+                      rc7806122
         /// Replaces enum types by int, and function/array types in function parameter and return
         /// lists by appropriate pointers
+        /*
         struct EnumAndPointerDecay_new {
                 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
 …
+                }
         };
+        */
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
 …
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
         ast::Pass< EnumAndPointerDecay_new > epc;
+        // ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
         ast::Pass< ForallPointerDecay_new > fpd{ loc };
         return type->accept( epc )->accept( lrt )->accept( fpd );
+        return type->accept( lrt )->accept( fpd );
+}

Context Navigation

Legend:

doc/LaTeXmacros/common.tex

doc/LaTeXmacros/lstlang.sty

doc/refrat/refrat.tex

doc/theses/andrew_beach_MMath/thesis.tex

doc/theses/fangren_yu_COOP_S20/Report.tex

doc/user/user.tex

src/AST/Convert.cpp

src/AST/Decl.hpp

src/AST/ForallSubstitutor.hpp

src/AST/Pass.impl.hpp

src/AST/SymbolTable.cpp

src/AST/SymbolTable.hpp

src/AST/Type.cpp

src/AST/Type.hpp

src/InitTweak/InitTweak.cc

src/ResolvExpr/CandidateFinder.cpp

src/ResolvExpr/CurrentObject.cc

src/ResolvExpr/Resolver.cc

src/ResolvExpr/SatisfyAssertions.cpp

src/ResolvExpr/SpecCost.cc

src/ResolvExpr/Unify.cc

src/SymTab/Mangler.cc

src/SymTab/Validate.cc

Download in other formats: