Meta: initial commit of WestCo optimized toolchain.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

1 files changed, 6750 insertions, 0 deletions

diff --git a/CompilerDriver/cc2/source/to_cpp1.h b/CompilerDriver/cc2/source/to_cpp1.h
new file mode 100644
index 0000000..a7b6782
--- /dev/null
+++ b/CompilerDriver/cc2/source/to_cpp1.h
@@ -0,0 +1,6750 @@
+
+//  Copyright (c) Herb Sutter
+//  SPDX-License-Identifier: CC-BY-NC-ND-4.0
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+
+//===========================================================================
+//  Lowering to Cpp1 syntax
+//===========================================================================
+
+#ifndef CPP2_TO_CPP1_H
+#define CPP2_TO_CPP1_H
+
+#include "sema.h"
+#include <iostream>
+#include <cstdio>
+#include <optional>
+
+namespace cpp2 {
+
+//  Defined out of line here just to avoid bringing <iostream> in before this,
+//  so that we can't accidentally start depending on iostreams in earlier phases
+auto cmdline_processor::print(std::string_view s, int width)
+    -> void
+{
+    if (width > 0) {
+        std::cout << std::setw(width) << std::left;
+    }
+    std::cout << s;
+}
+
+
+//-----------------------------------------------------------------------
+//
+//  Stringingizing helpers
+//
+//-----------------------------------------------------------------------
+
+auto pad(int padding)
+    -> std::string_view
+{
+    if (padding < 1) {
+        return "";
+    }
+
+    return {
+        indent_str.c_str(),
+        _as<size_t>( std::min( padding, _as<int>(std::ssize(indent_str))) )
+    };
+}
+
+
+//-----------------------------------------------------------------------
+//
+//  positional_printer: a Syntax 1 pretty printer
+//
+//-----------------------------------------------------------------------
+//
+static auto flag_emit_cppfront_info = false;
+static cmdline_processor::register_flag cmd_emit_cppfront_info(
+    9,
+    "emit-cppfront-info",
+    "Emit cppfront version/build in output file",
+    []{ flag_emit_cppfront_info = true; }
+);
+
+static auto flag_clean_cpp1 = false;
+static cmdline_processor::register_flag cmd_clean_cpp1(
+    9,
+    "clean-cpp1",
+    "Emit clean Cpp1 without #line directives",
+    []{ flag_clean_cpp1 = true; }
+);
+
+static auto flag_import_std = false;
+static cmdline_processor::register_flag cmd_import_std(
+    0,
+    "import-std",
+    "import all std:: via 'import std;' - ignored if -include-std is set",
+    []{ flag_import_std = true; }
+);
+
+static auto flag_include_std = false;
+static cmdline_processor::register_flag cmd_include_std(
+    0,
+    "include-std",
+    "#include all std:: headers",
+    []{ flag_include_std = true; }
+);
+
+static auto flag_cpp2_only = false;
+static cmdline_processor::register_flag cmd_cpp2_only(
+    0,
+    "pure-cpp2",
+    "Allow Cpp2 syntax only - also sets -import-std",
+    []{ flag_cpp2_only = true; flag_import_std = true; }
+);
+
+static auto flag_safe_null_pointers = true;
+static cmdline_processor::register_flag cmd_safe_null_pointers(
+    2,
+    "no-null-checks",
+    "Disable null safety checks",
+    []{ flag_safe_null_pointers = false; }
+);
+
+static auto flag_safe_subscripts = true;
+static cmdline_processor::register_flag cmd_safe_subscripts(
+    2,
+    "no-subscript-checks",
+    "Disable subscript safety checks",
+    []{ flag_safe_subscripts = false; }
+);
+
+static auto flag_safe_comparisons = true;
+static cmdline_processor::register_flag cmd_safe_comparisons(
+    2,
+    "no-comparison-checks",
+    "Disable mixed-sign comparison safety checks",
+    []{ flag_safe_comparisons = false; }
+);
+
+static auto flag_use_source_location = false;
+static cmdline_processor::register_flag cmd_enable_source_info(
+    2,
+    "add-source-info",
+    "Enable source_location information for contract checks",
+    []{ flag_use_source_location = true; }
+);
+
+static auto flag_cpp1_filename = std::string{};
+static cmdline_processor::register_flag cmd_cpp1_filename(
+    9,
+    "output filename",
+    "Output to 'filename' (can be 'stdout') - default is *.cpp/*.h",
+    nullptr,
+    [](std::string const& name) { flag_cpp1_filename = name; }
+);
+
+static auto flag_print_colon_errors = false;
+static cmdline_processor::register_flag cmd_print_colon_errors(
+    9,
+    "format-colon-errors",
+    "Emit ':line:col:' format for messages - lights up some tools",
+    []{ flag_print_colon_errors = true; }
+);
+
+static auto flag_verbose = false;
+static cmdline_processor::register_flag cmd_verbose(
+    9,
+    "verbose",
+    "Print verbose statistics and -debug output",
+    []{ flag_verbose = true; }
+);
+
+static auto flag_no_exceptions = false;
+static cmdline_processor::register_flag cmd_no_exceptions(
+    4,
+    "fno-exceptions",
+    "Disable C++ EH - failed 'as' for 'variant' will assert",
+    []{ flag_no_exceptions = true; }
+);
+
+static auto flag_no_rtti = false;
+static cmdline_processor::register_flag cmd_no_rtti(
+    4,
+    "fno-rtti",
+    "Disable C++ RTTI - using 'as' for '*'/'std::any' will assert",
+    []{ flag_no_rtti = true; }
+);
+
+struct text_with_pos{
+    std::string     text;
+    source_position pos;
+    text_with_pos(std::string const& t, source_position p) : text{t}, pos{p} { }
+};
+
+// Defined out of line so we can use flag_print_colon_errors.
+auto error_entry::print(
+    auto&              o,
+    std::string const& file
+) const
+    -> void
+{
+    o << file ;
+    if (where.lineno > 0) {
+        if (flag_print_colon_errors) {
+            o << ":" << (where.lineno);
+            if (where.colno >= 0) {
+                o << ":" << where.colno;
+            }
+        }
+        else {
+            o << "("<< (where.lineno);
+            if (where.colno >= 0) {
+                o << "," << where.colno;
+            }
+            o  << ")";
+        }
+    }
+    o << ":";
+    if (internal) {
+        o << " internal compiler";
+    }
+    o << " error: " << msg << "\n";
+}
+
+class positional_printer
+{
+    //  Core information
+    std::ofstream               out_file        = {}; // Cpp1 syntax output file
+    std::ostream*               out             = {}; // will point to out_file or cout
+    std::string                 cpp2_filename   = {};
+    std::string                 cpp1_filename   = {};
+    std::vector<comment> const* pcomments       = {}; // Cpp2 comments data
+    source const*               psource         = {};
+    parser const*               pparser         = {};
+
+    source_position curr_pos                    = {}; // current (line,col) in output
+    lineno_t        generated_pos_line          = {}; // current line in generated output
+    int             last_line_indentation       = {};
+    int             next_comment                = 0;  // index of the next comment not yet printed
+    bool            last_was_empty              = false;
+    int             empty_lines_suppressed      = 0;
+    bool            just_printed_line_directive = false;
+    bool            printed_extra               = false;
+    char            last_printed_char           = {};
+
+    struct req_act_info {
+        colno_t requested;
+        colno_t offset;
+
+        req_act_info(colno_t r, colno_t o) : requested{r}, offset{o} { }
+    };
+    struct {
+        lineno_t line = {};
+        std::vector<req_act_info> requests = {};
+    } prev_line_info = {};
+
+    //  Position override information
+    std::vector<source_position> preempt_pos = {};  // use this position instead of the next supplied one
+    int             pad_for_this_line   = 0;        // extra padding to add/subtract for this line only
+    bool            ignore_align        = false;
+    int             ignore_align_indent = 0;
+    lineno_t        ignore_align_lineno = 0;
+    bool            enable_indent_heuristic = true;
+
+public:
+    //  Modal information
+    enum phases {
+        phase0_type_decls           = 0,
+        phase1_type_defs_func_decls = 1,
+        phase2_func_defs            = 2
+    };
+    auto get_phase() const { return phase; }
+
+private:
+    phases phase = phase0_type_decls;
+
+    auto inc_phase() -> void {
+        switch (phase) {
+        break;case phase0_type_decls          : phase = phase1_type_defs_func_decls;
+        break;case phase1_type_defs_func_decls: phase = phase2_func_defs;
+        break;default                         : assert(!"ICE: invalid lowering phase");
+        }
+        curr_pos     = {};
+        next_comment = 0;   // start over with the comments
+    }
+
+    std::vector<std::string*>                emit_string_targets;       // option to emit to string instead of out file
+    std::vector<std::vector<text_with_pos>*> emit_text_chunks_targets;  // similar for vector<text_pos>
+
+    enum class target_type { string, chunks };
+    std::vector<target_type>                 emit_target_stack;         // to interleave them sensibly
+
+
+    //-----------------------------------------------------------------------
+    //  Print text
+    //
+    auto print(
+        std::string_view s,
+        source_position  pos = source_position{},
+        bool             track_curr_pos = true,
+        bool             is_known_empty = false
+    )
+        -> void
+    {
+        //  Take ownership of (and reset) just_printed_line_directive value
+        auto line_directive_already_done = std::exchange(just_printed_line_directive, false);
+
+        //  If the caller is capturing this output, emit to the
+        //  current target instead and skip most positioning logic
+        if (!emit_target_stack.empty())
+        {
+            //  If capturing to a string, emit to the specified string
+            if (emit_target_stack.back() == target_type::string) {
+                assert(!emit_string_targets.empty());
+                *emit_string_targets.back() += s;
+            }
+
+            //  If capturing to a vector of chunks, emit to that
+            else {
+                assert(!emit_text_chunks_targets.empty());
+                emit_text_chunks_targets.back()->insert( emit_text_chunks_targets.back()->begin(), text_with_pos(std::string(s), pos) );
+            }
+
+            return;
+        }
+
+        //  Otherwise, we'll actually print the string to the output file
+        //  and update our curr_pos position
+
+        if (s.length() > 0) {
+            last_printed_char = s.back();
+        }
+
+        //  Reject consecutive empty lines: If this line is empty
+        if (
+            ( s == "\n" || is_known_empty )
+            && curr_pos.colno <= 1
+            )
+        {
+            //  And so was the last one, update logical position only
+            //  and increment empty_lines_suppressed instead of printing
+            if (last_was_empty) {
+                if (track_curr_pos) {
+                    ++curr_pos.lineno;
+                    curr_pos.colno = 1;
+                }
+                ++empty_lines_suppressed;
+                return;
+            }
+            //  If this is the first consecutive empty, remember and continue
+            last_was_empty = true;
+        }
+        //  Otherwise, if this line is not empty
+        else {
+            //  Remember that this line was not empty
+            last_was_empty = false;
+
+            //  And if we did suppress any empties, emit a #line to resync
+            if (empty_lines_suppressed > 0) {
+                if (!line_directive_already_done) {
+                    print_line_directive(curr_pos.lineno);
+                }
+                empty_lines_suppressed = 0;
+            }
+        }
+
+        //  Output the string
+        assert (out);
+        *out << s;
+
+        //  Update curr_pos by finding how many line breaks s contained,
+        //  and where the last one was which determines our current colno
+        if (track_curr_pos)
+        {
+            auto last_newline = std::string::npos;  // the last newline we found in the string
+            auto newline_pos  = std::size_t(0);     // the current newline we found in the string
+            while ((newline_pos = s.find('\n', newline_pos)) != std::string::npos)
+            {
+                //  For each line break we find, reset pad and inc current lineno
+                pad_for_this_line = 0;
+                ++curr_pos.lineno;
+                last_newline = newline_pos;
+                ++newline_pos;
+            }
+
+            //  Now also adjust the colno
+            if (last_newline != std::string::npos) {
+                //  If we found a newline, it's the distance from the last newline to EOL
+                curr_pos.colno = s.length() - last_newline;
+            }
+            else {
+                //  Else add the length of the string
+                curr_pos.colno += s.length();
+            }
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Internal helpers
+
+    //  Start a new line if we're not in col 1 already
+    //
+    auto ensure_at_start_of_new_line()
+        -> void
+    {
+        if (curr_pos.colno > 1) {
+            auto old_pos = curr_pos;
+            print( "\n" );
+            assert(curr_pos.lineno == old_pos.lineno+1);
+            assert(curr_pos.colno == 1);
+        }
+    }
+
+    //  Print a #line directive
+    //
+    auto print_line_directive( lineno_t line )
+        -> void
+    {
+        //  Ignore requests from generated code (negative line numbers)
+        if (line < 1) {
+            return;
+        }
+
+        //  Otherwise, implement the request
+        prev_line_info = { curr_pos.lineno, { } };
+        ensure_at_start_of_new_line();
+
+        //  Not using print() here because this is transparent to the curr_pos
+        if (!flag_clean_cpp1) {
+            assert (out);
+            *out << "#line " << line << " " << std::quoted(cpp2_filename) << "\n";
+        }
+        just_printed_line_directive = true;
+    }
+
+    //  Catch up with comment/blank lines
+    //
+    auto print_comment(comment const& c)
+        -> void
+    {
+        //  For a line comment, start it at the right indentation and print it
+        //  with a newline end
+        if (c.kind == comment::comment_kind::line_comment) {
+            print( pad( c.start.colno - curr_pos.colno + 1 ) );
+            print( c.text );
+            assert( c.text.find("\n") == std::string::npos );  // we shouldn't have newlines
+            print("\n");
+        }
+
+        //  For a stream comment, pad out to its column (if we haven't passed it already)
+        //  and emit it there
+        else {
+            print( pad( c.start.colno - curr_pos.colno ) );
+            print( c.text );
+        }
+
+        c.dbg_was_printed = true;
+    }
+
+    auto flush_comments( source_position pos )
+        -> void
+    {
+        if (!pcomments) {
+            return;
+        }
+
+        //  For convenience
+        auto& comments = *pcomments;
+
+        //  Add unprinted comments and blank lines as needed to catch up vertically
+        //
+        while (curr_pos.lineno < pos.lineno)
+        {
+            //  If a comment goes on this line, print it
+            if (
+                next_comment < std::ssize(comments)
+                && comments[next_comment].start.lineno <= curr_pos.lineno
+                )
+            {
+                //  Emit non-function body comments in phase1_type_defs_func_decls,
+                //  and emit function body comments in phase2_func_defs
+                assert(pparser);
+                if (
+                    (
+                        phase == phase1_type_defs_func_decls
+                        && !pparser->is_within_function_body( comments[next_comment].start.lineno )
+                        )
+                    ||
+                    (
+                        phase == phase2_func_defs
+                        && pparser->is_within_function_body( comments[next_comment].start.lineno )
+                        )
+                    )
+                {
+                    print_comment( comments[next_comment] );
+                    assert(curr_pos.lineno <= pos.lineno);  // we shouldn't have overshot
+                }
+
+                ++next_comment;
+            }
+
+            //  Otherwise, just print a blank line
+            else {
+                print("\n");
+            }
+        }
+    }
+
+    auto print_unprinted_comments()
+    {
+        for (auto const& c : *pcomments) {
+            if (!c.dbg_was_printed) {
+                print_comment(c);
+            }
+        }
+    }
+
+    //  Position ourselves as close to pos as possible,
+    //  and catch up with displaying comments
+    //
+    auto align_to( source_position pos )
+        -> void
+    {
+        auto on_same_line = curr_pos.lineno == pos.lineno;
+
+        //  Ignoring this logic is used when we're generating new code sections,
+        //  such as return value structs, and emitting raw string literals
+        if (ignore_align) {
+            print( pad( ignore_align_indent - curr_pos.colno ) );
+            return;
+        }
+
+        //  Otherwise, we need to apply our usual alignment logic
+
+        //  Catch up with displaying comments
+        flush_comments( pos );
+
+        //  If we're not on the right line
+        if (
+            printed_extra
+            && !on_same_line
+            )
+        {
+            print_line_directive(pos.lineno);
+            curr_pos.lineno = pos.lineno;
+            printed_extra = false;
+        }
+        else if (curr_pos.lineno < pos.lineno)
+        {
+            //  In case we're just one away, try a blank line
+            //  (this might get ignored and we'll get the line directive)
+            print( "\n" );
+            if (curr_pos.lineno != pos.lineno) {
+                print_line_directive(pos.lineno);
+            }
+            curr_pos.lineno = pos.lineno;
+        }
+
+        //  Finally, align to the target column, if we're on the right line
+        //  and not one-past-the-end on the extra line at section end)
+        assert(
+            psource
+            && 0 <= curr_pos.lineno
+            && curr_pos.lineno < std::ssize(psource->get_lines())+1
+        );
+        if (
+            curr_pos.lineno == pos.lineno
+            && curr_pos.lineno < std::ssize(psource->get_lines())
+            )
+        {
+            //  Record this line's indentation as the 'last' line for next time
+            last_line_indentation = psource->get_lines()[curr_pos.lineno].indent();
+
+            //  If this line was originally densely spaced (had <2 whitespace
+            //  between all tokens), then the programmer likely wasn't doing a lot
+            //  of special formatting...
+            if (psource->get_lines()[curr_pos.lineno].all_tokens_are_densely_spaced)
+            {
+                //  For the first token in a line, use the line's original indentation
+                if (curr_pos.colno <= 1)
+                {
+                    print( pad( psource->get_lines()[curr_pos.lineno].indent() ) );
+                }
+                //  For later tokens, don't try to add padding
+                else {
+                    if (
+                        last_printed_char == ';'
+                        && on_same_line
+                        )
+                    {
+                        print( " " );
+                    }
+                }
+            }
+            //  Otherwise, make a best effort to adjust position with some padding
+            else
+            {
+                pos.colno = std::max( 1, pos.colno + pad_for_this_line );
+                print( pad( pos.colno - curr_pos.colno ) );
+            }
+        }
+    }
+
+
+public:
+    //-----------------------------------------------------------------------
+    //  Finalize phase
+    //
+    auto finalize_phase(bool print_remaining_comments = false)
+    {
+        if (
+            is_open()
+            && psource
+            && psource->has_cpp2()
+            )
+        {
+            flush_comments( {curr_pos.lineno+1, 1} );
+
+            if (print_remaining_comments) {
+                print_unprinted_comments();
+            }
+
+            //  Always make sure the very last line ends with a newline
+            //  (not really necessary but makes some tools quieter)
+            //  -- but only if there's any Cpp2, otherwise don't
+            //  because passing through all-Cpp1 code should always
+            //  remain diff-identical
+            if (phase == phase2_func_defs) {
+                print_extra("\n");
+            }
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Open
+    //
+    auto open(
+        std::string                 cpp2_filename_,
+        std::string                 cpp1_filename_,
+        std::vector<comment> const& comments,
+        cpp2::source const&         source,
+        cpp2::parser const&         parser
+    )
+        -> void
+    {
+        cpp2_filename = cpp2_filename_;
+        assert(
+            !is_open()
+            && !pcomments
+            && "ICE: tried to call .open twice"
+        );
+        cpp1_filename = cpp1_filename_;
+        if (cpp1_filename == "stdout") {
+            out = &std::cout;
+        }
+        else {
+            out_file.open(cpp1_filename);
+            out = &out_file;
+        }
+        pcomments = &comments;
+        psource   = &source;
+        pparser   = &parser;
+    }
+
+    auto reopen()
+        -> void
+    {
+        assert(
+            is_open()
+            && "ICE: tried to call .reopen without first calling .open"
+        );
+        assert(cpp1_filename.ends_with(".h"));
+        out_file.close();
+        out_file.open(cpp1_filename + "pp");
+    }
+
+    auto is_open()
+        -> bool
+    {
+        if (out) {
+            assert(
+                pcomments
+                && "ICE: if is_open, pcomments should also be set"
+            );
+        }
+        return out;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Abandon: close and delete
+    //
+    auto abandon()
+        -> void
+    {
+        if (!is_open()) {
+            return;
+        }
+        if (out_file.is_open()) {
+            out_file.close();
+            std::remove(cpp1_filename.c_str());
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Print extra text and don't track positions
+    //  Used for Cpp2 boundary comment and prelude and final newline
+    //
+    auto print_extra( std::string_view s )
+        -> void
+    {
+        assert(
+            is_open()
+            && "ICE: printer must be open before printing"
+        );
+        print( s, source_position{}, false );
+        printed_extra = true;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Print a Cpp1 line, which should be at lineno
+    //
+    auto print_cpp1( std::string_view s, lineno_t line )
+        -> void
+    {
+        assert(
+            is_open()
+            && line >= 0
+            && "ICE: printer must be open before printing, and line number must not be negative (Cpp1 code is never generated)"
+        );
+
+        //  Always start a Cpp1 line on its own new line
+        ensure_at_start_of_new_line();
+
+        //  If we are out of sync with the current logical line number,
+        //  emit a #line directive to re-sync
+        if (curr_pos.lineno != line) {
+            print_line_directive( line );
+            curr_pos.lineno = line;
+        }
+
+        //  Print the line
+        assert (curr_pos.colno == 1);
+        print( s );
+        print( "\n" );
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Used when we start a new Cpp2 section, or when we emit the same item
+    //  more than once (notably when we emit operator= more than once)
+    //
+    auto reset_line_to(lineno_t line, bool force = false)
+        -> void
+    {
+        //  Always start a Cpp2 section on its own new line
+        ensure_at_start_of_new_line();
+
+        //  If we are out of sync with the current logical line number,
+        //  emit a #line directive to re-sync
+        if (
+            force
+            || curr_pos.lineno != line
+            )
+        {
+            print_line_directive( line );
+            curr_pos.lineno = line;
+        }
+
+        assert (curr_pos.colno == 1);
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Print a Cpp2 item, which should be at pos
+    //
+    auto print_cpp2(
+        std::string_view s,
+        source_position  pos,
+        bool             leave_newlines_alone = false,
+        bool             is_known_empty = false
+
+    )
+        -> void
+    {
+        //  If we're printing for real (not to a string target)
+        if (emit_target_stack.empty())
+        {
+            //  If we're in a generated text region (signified by negative
+            //  line numbers), then shunt this call to print_extra instead
+            if (pos.lineno < 1) {
+                if (generated_pos_line != pos.lineno) {
+                    *out << "\n" + std::string(last_line_indentation, ' ');
+                    generated_pos_line = pos.lineno;
+                }
+                print_extra(s);
+                return;
+            }
+
+            //  Otherwise, we're no longer in generated code, so reset the
+            //  generated code counter
+            generated_pos_line = {};
+        }
+
+        assert(
+            is_open()
+            && "ICE: printer must be open before printing"
+        );
+
+        //  If there are any embedded newlines, split this string into
+        //  separate print_cpp2 calls
+        if (auto newline_pos = s.find('\n');
+            !leave_newlines_alone
+            && s.length() > 1
+            && newline_pos != s.npos
+            )
+        {
+            while (newline_pos != std::string_view::npos)
+            {
+                //  Print the text before the next newline
+                if (newline_pos > 0) {
+                    print_cpp2( s.substr(0, newline_pos), pos );
+                }
+
+                //  Emit the newline as a positioned empty string
+                assert (s[newline_pos] == '\n');
+                ++pos.lineno;
+                pos.colno = 1;
+                print_cpp2( "", pos, false, curr_pos.colno <= 1 );
+
+                s.remove_prefix( newline_pos+1 );
+                newline_pos = s.find('\n');
+            }
+            //  Print any tail following the last newline
+            if (!s.empty()) {
+                print_cpp2( s, pos );
+            }
+            return;
+        }
+
+        //  The rest of this call handles a single chunk that's either a
+        //  standalone "\n" or a piece of text that doesn't have a newline
+
+        //  Skip alignment work if we're capturing emitted text
+        if (emit_target_stack.empty())
+        {
+            //  Remember where we are
+            auto last_pos = curr_pos;
+
+            //  We may want to adjust the position based on (1) a position preemption request
+            //  or else (2) to repeat a similar adjustment we discovered on the previous line
+            auto adjusted_pos = pos;
+
+            //  (1) See if there's a position preemption request, if so use it up
+            //      For now, the preempt position use cases are about overriding colno
+            //      and only on the same line. In the future, we might have more use cases.
+            if (!preempt_pos.empty()) {
+                if (preempt_pos.back().lineno == pos.lineno) {
+                    adjusted_pos.colno = preempt_pos.back().colno;
+                }
+            }
+
+            //  (2) Otherwise, see if there's a previous line's offset to repeat
+            //      If we moved to a new line, then this is the first
+            //      non-comment non-whitespace text on the new line
+            else if (
+                last_pos.lineno == pos.lineno-1
+                && enable_indent_heuristic
+                )
+            {
+                //  If the last line had a request for this colno, remember its actual offset
+                constexpr int sentinel = -100;
+                auto last_line_offset = sentinel;
+                for(auto i = 0;
+                    i < std::ssize(prev_line_info.requests)
+                        && prev_line_info.requests[i].requested <= pos.colno;
+                    ++i
+                    )
+                {
+                    if (prev_line_info.requests[i].requested == pos.colno)
+                    {
+                        last_line_offset = prev_line_info.requests[i].offset;
+                        break;
+                    }
+                }
+
+                //  If there was one, apply the actual column number offset
+                if (last_line_offset > sentinel) {
+                    adjusted_pos.colno += last_line_offset;
+                }
+            }
+            enable_indent_heuristic = true;
+
+            //  If we're changing lines, start accumulating this new line's request/actual adjustment info
+            if (last_pos.lineno < adjusted_pos.lineno) {
+                prev_line_info = { curr_pos.lineno, { } };
+            }
+
+            align_to(adjusted_pos);
+
+            //  Remember the requested and actual offset columns for this item
+            prev_line_info.requests.push_back( req_act_info( pos.colno /*requested*/ , curr_pos.colno /*actual*/ - pos.colno ) );
+        }
+
+        print(s, pos, true, is_known_empty );
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Position override control functions
+    //
+
+    //  Use this position instead of the next supplied one
+    //  Useful when Cpp1 syntax is emitted in a different order/verbosity
+    //  than Cpp2 such as with declarations
+    //
+    auto preempt_position_push(source_position pos)
+        -> void
+    {
+        preempt_pos.push_back( pos );
+    }
+
+    auto preempt_position_pop()
+        -> void
+    {
+        assert(!preempt_pos.empty());
+        preempt_pos.pop_back();
+    }
+
+    //  Add (or, if negative, subtract) padding for the current line only
+    //
+    auto add_pad_in_this_line(colno_t extra)
+        -> void
+    {
+        pad_for_this_line += extra;
+    }
+
+    //  Enable indent heuristic for just this line
+    //
+    auto disable_indent_heuristic_for_next_text()
+        -> void
+    {
+        enable_indent_heuristic = false;
+    }
+
+    //  Ignore position information, usually when emitting generated code
+    //  such as generated multi-return type structs
+    //
+    auto ignore_alignment(
+        bool ignore,
+        int  indent = 0
+    )
+        -> void
+    {
+        //  We'll only ever call this in local non-nested true/false pairs.
+        //  If we ever want to generalize (support nesting, or make it non-brittle),
+        //  wrap this in a push/pop stack.
+        if (ignore) {
+            ignore_align        = true;
+            ignore_align_indent = indent;
+            ignore_align_lineno = curr_pos.lineno;      // push state
+        }
+        else {
+            ignore_align        = false;
+            ignore_align_indent = 0;
+            curr_pos.lineno     = ignore_align_lineno;  // pop state
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Modal state control functions
+    //
+
+    auto next_phase()
+        -> void
+    {
+        inc_phase();
+    }
+
+    //  Provide an option to store to a given string instead, which is
+    //  useful for capturing Cpp1-formatted output for generated code
+    //
+    auto emit_to_string( std::string* target = {} )
+        -> void
+    {
+        if (target) {
+            emit_string_targets.push_back( target );
+            emit_target_stack.push_back(target_type::string);
+        }
+        else {
+            emit_string_targets.pop_back();
+            emit_target_stack.pop_back();
+        }
+    }
+
+    //  Provide an option to store to a vector<text_with_pos>, which is
+    //  useful for postfix expression which have to mix unwrapping operators
+    //  with emitting sub-elements such as expression lists
+    //
+    auto emit_to_text_chunks( std::vector<text_with_pos>* target = {} )
+        -> void
+    {
+        if (target) {
+            emit_text_chunks_targets.push_back( target );
+            emit_target_stack.push_back(target_type::chunks);
+        }
+        else {
+            emit_text_chunks_targets.pop_back();
+            emit_target_stack.pop_back();
+        }
+    }
+
+};
+
+
+//-----------------------------------------------------------------------
+//
+//  cppfront: a compiler instance
+//
+//-----------------------------------------------------------------------
+//
+struct function_prolog {
+    std::vector<std::string> mem_inits  = {};
+    std::vector<std::string> statements = {};
+};
+
+class cppfront
+{
+    std::string              sourcefile;
+    std::vector<error_entry> errors;
+
+    //  For building
+    //
+    cpp2::source source;
+    cpp2::tokens tokens;
+    cpp2::parser parser;
+    cpp2::sema   sema;
+
+    bool source_loaded                  = true;
+    bool last_postfix_expr_was_pointer  = false;
+    bool violates_bounds_safety         = false;
+    bool violates_initialization_safety = false;
+    bool suppress_move_from_last_use    = false;
+
+    declaration_node const* having_signature_emitted = {};
+
+    declaration_node const*   generating_assignment_from      = {};
+    declaration_node const*   generating_move_from            = {};
+    declaration_node const*   generating_postfix_inc_dec_from = {};
+    bool                      emitting_that_function          = false;
+    bool                      emitting_move_that_function     = false;
+    std::vector<token const*> already_moved_that_members      = {};
+
+    struct arg_info {
+        passing_style pass   = passing_style::in;
+        token const*  ptoken = {};
+    };
+    std::vector<arg_info> current_args  = { {} };
+
+    struct active_using_declaration {
+        token const* identifier = {};
+
+        explicit active_using_declaration(using_statement_node const& n) {
+          if (auto id = get_if<id_expression_node::qualified>(&n.id->id)) {
+              identifier = (*id)->ids.back().id->identifier;
+          }
+        }
+    };
+
+    using source_order_name_lookup_res =
+        std::optional<std::variant<declaration_node const*, active_using_declaration>>;
+
+    //  Stack of the currently active nested declarations we're inside
+    std::vector<declaration_node const*> current_declarations = { {} };
+
+    //  Stack of the currently active names for source order name lookup:
+    //  Like 'current_declarations' + also parameters and using declarations
+    std::vector<source_order_name_lookup_res::value_type> current_names = { {} };
+
+    //  Maintain a stack of the functions we're currently processing, which can
+    //  be up to MaxNestedFunctions in progress (if we run out, bump the Max).
+    //  The main reason for this is to be able to pass function_info's, especially
+    //  their .epilog, by reference for performance while still having lifetime safety
+    struct function_info
+    {
+        declaration_node const*                    decl                         = {};
+        function_type_node const*                  func                         = {};
+        declaration_node::declared_value_set_funcs declared_value_set_functions = {};
+        function_prolog                            prolog                       = {};
+        std::vector<std::string>                   epilog                       = {};
+
+        function_info(
+            declaration_node const*                    decl_,
+            function_type_node const*                  func_,
+            declaration_node::declared_value_set_funcs declared_value_set_functions_
+        )
+            : decl{decl_}
+            , func{func_}
+            , declared_value_set_functions{declared_value_set_functions_}
+        { }
+    };
+    class current_functions_
+    {
+        std::deque<function_info> list = { {} };
+    public:
+        auto push(
+            declaration_node const*                    decl,
+            function_type_node const*                  func,
+            declaration_node::declared_value_set_funcs thats
+        ) {
+            list.emplace_back(decl, func, thats);
+        }
+
+        auto pop() {
+            list.pop_back();
+        }
+
+        auto back() -> function_info& {
+            assert(!empty());
+            return list.back();
+        }
+
+        auto empty() -> bool {
+            return list.empty();
+        }
+    };
+    current_functions_ current_functions;
+
+    //  For lowering
+    //
+    positional_printer printer;
+    bool               in_definite_init  = false;
+    bool               in_parameter_list = false;
+
+    std::string                                   function_return_name;
+    struct function_return {
+        parameter_declaration_list_node* param_list;
+        passing_style                    pass;
+        bool                             is_deduced;
+
+        function_return(
+            parameter_declaration_list_node* param_list_,
+            passing_style                    pass_ = passing_style::invalid,
+            bool                             is_deduced_ = false
+        )
+            : param_list{param_list_}
+            , pass{pass_}
+            , is_deduced{is_deduced_}
+        { }
+    };
+    std::vector<function_return>         function_returns;
+    parameter_declaration_list_node      single_anon;
+        //  special value - hack for now to note single-anon-return type kind in this function_returns working list
+    std::vector<std::string>                      function_requires_conditions;
+
+    struct iter_info {
+        iteration_statement_node const* stmt;
+        bool used = false;
+    };
+    std::vector<iter_info> iteration_statements;
+
+    std::vector<bool>                             in_non_rvalue_context   = { false };
+    std::vector<bool>                             need_expression_list_parens = { true };
+    auto push_need_expression_list_parens( bool b ) -> void { need_expression_list_parens.push_back(b);            }
+    auto pop_need_expression_list_parens()          -> void { assert(std::ssize(need_expression_list_parens) > 1);
+                                                              need_expression_list_parens.pop_back();              }
+    auto should_add_expression_list_parens()        -> bool { assert(!need_expression_list_parens.empty());
+                                                              return need_expression_list_parens.back();           }
+    auto consumed_expression_list_parens()          -> void { if( std::ssize(need_expression_list_parens) > 1 )
+                                                                  need_expression_list_parens.back() = false;      }
+
+public:
+    //-----------------------------------------------------------------------
+    //  Constructor
+    //
+    //  filename    the source file to be processed
+    //
+    cppfront(std::string const& filename)
+        : sourcefile{ filename }
+        , source    { errors }
+        , tokens    { errors }
+        , parser    { errors }
+        , sema      { errors }
+    {
+        //  "Constraints enable creativity in the right directions"
+        //  sort of applies here
+        //
+        if (
+            !sourcefile.ends_with(".cpp2")
+            && !sourcefile.ends_with(".h2")
+            )
+        {
+            errors.emplace_back(
+                source_position(-1, -1),
+                "source filename must end with .cpp2 or .h2: " + sourcefile
+            );
+        }
+
+        //  Load the program file into memory
+        //
+        else if (!source.load(sourcefile))
+        {
+            if (errors.empty()) {
+                errors.emplace_back(
+                    source_position(-1, -1),
+                    "file not found: " + sourcefile
+                );
+            }
+            source_loaded = false;
+        }
+
+        else
+        {
+            //  Tokenize
+            //
+            tokens.lex(source.get_lines());
+
+            //  Parse
+            //
+            try
+            {
+                for (auto const& [line, entry] : tokens.get_map()) {
+                    if (!parser.parse(entry, tokens.get_generated())) {
+                        errors.emplace_back(
+                            source_position(line, 0),
+                            "parse failed for section starting here",
+                            false,
+                            true    // a noisy fallback error message
+                        );
+                    }
+                }
+
+                //  Sema
+                parser.visit(sema);
+                if (!sema.apply_local_rules()) {
+                    violates_initialization_safety = true;
+                }
+            }
+            catch (std::runtime_error& e) {
+                errors.emplace_back(
+                    source_position(-1, -1),
+                    e.what()
+                );
+            }
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  lower_to_cpp1
+    //
+    //  Emits the target file with the last '2' stripped
+    //
+    struct lower_to_cpp1_ret {
+        lineno_t cpp1_lines = 0;
+        lineno_t cpp2_lines = 0;
+    };
+    auto lower_to_cpp1()
+        -> lower_to_cpp1_ret
+    {
+        auto ret = lower_to_cpp1_ret{};
+
+        //  Only lower to Cpp1 if we haven't already encountered errors
+        if (!errors.empty()) {
+            return {};
+        }
+
+        //  Now we'll open the Cpp1 file
+        auto cpp1_filename = sourcefile.substr(0, std::ssize(sourcefile) - 1);
+        if (!flag_cpp1_filename.empty()) {
+            cpp1_filename = flag_cpp1_filename; // use override if present
+        }
+
+        printer.open(
+            sourcefile,
+            cpp1_filename,
+            tokens.get_comments(),
+            source,
+            parser
+        );
+        if (!printer.is_open()) {
+            errors.emplace_back(
+                source_position{},
+                "could not open output file " + cpp1_filename
+            );
+            return {};
+        }
+
+        //  Generate a reasonable macroized name
+        auto cpp1_FILENAME = to_upper_and_underbar(cpp1_filename);
+
+
+        //---------------------------------------------------------------------
+        //  Do lowered file prolog
+        //
+        //  Only emit extra lines if we actually have Cpp2, because
+        //  we want Cpp1-only files to pass through with zero changes
+        //  (unless the user requested import/include of std)
+        if (
+            source.has_cpp2()
+            || flag_import_std
+            || flag_include_std
+            )
+        {
+            if (flag_emit_cppfront_info) {
+                printer.print_extra(
+                    "\n// Generated by cppfront "
+                    #include "version.info"
+                    " build " 
+                    #include "build.info"
+                );
+            }
+            printer.print_extra( "\n" );
+            if (cpp1_filename.back() == 'h') {
+                printer.print_extra( "#ifndef " + cpp1_FILENAME+"_CPP2\n");
+                printer.print_extra( "#define " + cpp1_FILENAME+"_CPP2" + "\n\n" );
+            }
+
+            if (flag_use_source_location) {
+                printer.print_extra( "#define CPP2_USE_SOURCE_LOCATION Yes\n" );
+            }
+
+            if (flag_include_std) {
+                printer.print_extra( "#define CPP2_INCLUDE_STD         Yes\n" );
+            }
+            else if (flag_import_std) {
+                printer.print_extra( "#define CPP2_IMPORT_STD          Yes\n" );
+            }
+
+            if (flag_no_exceptions) {
+                printer.print_extra( "#define CPP2_NO_EXCEPTIONS       Yes\n" );
+            }
+
+            if (flag_no_rtti) {
+                printer.print_extra( "#define CPP2_NO_RTTI             Yes\n" );
+            }
+        }
+
+        auto map_iter = tokens.get_map().cbegin();
+        auto hpp_includes = std::string{};
+
+
+        //---------------------------------------------------------------------
+        //  Do phase0_type_decls
+        assert(printer.get_phase() == printer.phase0_type_decls);
+
+        if (
+            source.has_cpp2()
+            && !flag_clean_cpp1
+            )
+        {
+            printer.print_extra( "\n//=== Cpp2 type declarations ====================================================\n\n" );
+        }
+
+        if (
+            !tokens.get_map().empty()
+            || flag_import_std
+            || flag_include_std
+            )
+        {
+            printer.print_extra( "\n#include \"cpp2util.h\"\n\n" );
+        }
+
+        if (
+            source.has_cpp2()
+            && !flag_clean_cpp1
+            )
+        {
+            printer.reset_line_to(1, true);
+        }
+
+        for (auto& section : tokens.get_map())
+        {
+            assert (!section.second.empty());
+
+            //  Get the parse tree for this section and emit each forward declaration
+            auto decls = parser.get_parse_tree_declarations_in_range(section.second);
+            for (auto& decl : decls) {
+                assert(decl);
+                emit(*decl);
+            }
+        }
+
+
+        //---------------------------------------------------------------------
+        //  Do phase1_type_defs_func_decls
+        //
+        printer.finalize_phase();
+        printer.next_phase();
+
+        if (
+            source.has_cpp2()
+            && !flag_clean_cpp1
+            )
+        {
+            printer.print_extra( "\n//=== Cpp2 type definitions and function declarations ===========================\n\n" );
+            printer.reset_line_to(1, true);
+        }
+
+        assert (printer.get_phase() == positional_printer::phase1_type_defs_func_decls);
+        for (
+            lineno_t curr_lineno = 0;
+            auto const& line : source.get_lines()
+            )
+        {
+            //  Skip dummy line we added to make 0-vs-1-based offsets readable
+            if (curr_lineno != 0)
+            {
+                //  If it's a Cpp1 line, emit it
+                if (line.cat != source_line::category::cpp2)
+                {
+                    if (
+                        source.has_cpp2()
+                        && line.cat != source_line::category::preprocessor
+                        )
+                    {
+                        ++ret.cpp2_lines;
+                    }
+                    else
+                    {
+                        ++ret.cpp1_lines;
+                    }
+
+                    if (
+                        flag_cpp2_only
+                        && !line.text.empty()
+                        && line.cat != source_line::category::comment
+                        && line.cat != source_line::category::import
+                        )
+                    {
+                        if (line.cat == source_line::category::preprocessor) {
+                            if (!line.text.ends_with(".h2\"")) {
+                                errors.emplace_back(
+                                    source_position(curr_lineno, 1),
+                                    "pure-cpp2 switch disables the preprocessor, including #include (except of .h2 files) - use import instead (note: 'import std;' is implicit in -pure-cpp2)"
+                                );
+                                return {};
+                            }
+                        }
+                        else {
+                            errors.emplace_back(
+                                source_position(curr_lineno, 1),
+                                "pure-cpp2 switch disables Cpp1 syntax"
+                            );
+                            return {};
+                        }
+                    }
+
+                    if (
+                        line.cat == source_line::category::preprocessor
+                        && line.text.ends_with(".h2\"")
+                        )
+                    {
+                        //  Strip off the 2"
+                        auto h_include = line.text.substr(0, line.text.size()-2);
+                        printer.print_cpp1( h_include + "\"", curr_lineno );
+                        hpp_includes += h_include + "pp\"\n";
+                    }
+                    else {
+                        printer.print_cpp1( line.text, curr_lineno );
+                    }
+                }
+
+                //  If it's a Cpp2 line...
+                else {
+                    ++ret.cpp2_lines;
+
+                    //  We should be in a position to emit a set of Cpp2 declarations
+                    if (
+                        map_iter != tokens.get_map().cend()
+                        && map_iter->first /*line*/ <= curr_lineno
+                        )
+                    {
+                        //  We should be here only when we're at exactly the first line of a Cpp2 section
+                        assert (map_iter->first == curr_lineno);
+                        assert (!map_iter->second.empty());
+
+                        //  Get the parse tree for this section and emit each forward declaration
+                        auto decls = parser.get_parse_tree_declarations_in_range(map_iter->second);
+                        for (auto& decl : decls) {
+                            assert(decl);
+                            emit(*decl);
+                        }
+                        ++map_iter;
+                    }
+                }
+            }
+            ++curr_lineno;
+        }
+
+        //  We can stop here if there's no Cpp2 code -- a file with no Cpp2
+        //  should have perfect passthrough verifiable with diff, including
+        //  that we didn't misidentify anything as Cpp2 (even in the
+        //  presence of nonstandard vendor extensions)
+        //
+        if (!source.has_cpp2()) {
+            assert(ret.cpp2_lines == 0);
+            return ret;
+        }
+
+        //  If there is Cpp2 code, we have more to do...
+
+        //  First, if this is a .h2 and in a -pure-cpp2 compilation,
+        //  we need to switch filenames
+        if (
+            cpp1_filename.back() == 'h'
+            && flag_cpp2_only
+            )
+        {
+            printer.print_extra( "\n#endif\n" );
+
+            printer.reopen();
+            if (!printer.is_open()) {
+                errors.emplace_back(
+                    source_position{},
+                    "could not open second output file " + cpp1_filename
+                );
+                return {};
+            }
+
+            printer.print_extra( "\n#ifndef " + cpp1_FILENAME+"_CPP2" );
+            printer.print_extra( "\n#error This file is part of a '.h2' header compiled to be consumed from another -pure-cpp2 file. To use this file, write '#include \"" + cpp1_filename + "2\"' in a '.h2' or '.cpp2' file compiled with -pure-cpp2."  );
+            printer.print_extra( "\n#endif\n" );
+
+            cpp1_FILENAME += "PP";
+            printer.print_extra( "\n#ifndef " + cpp1_FILENAME+"_CPP2" );
+            printer.print_extra( "\n#define " + cpp1_FILENAME+"_CPP2" + "\n\n" );
+
+            printer.print_extra( hpp_includes );
+        }
+
+
+        //---------------------------------------------------------------------
+        //  Do phase2_func_defs
+        //
+        printer.finalize_phase();
+        printer.next_phase();
+
+        if (
+            source.has_cpp2()
+            && !flag_clean_cpp1
+            )
+        {
+            printer.print_extra( "\n//=== Cpp2 function definitions =================================================\n\n" );
+            printer.reset_line_to(1, true);
+        }
+
+        for (auto& section : tokens.get_map())
+        {
+            assert (!section.second.empty());
+
+            //  Get the parse tree for this section and emit each forward declaration
+            auto decls = parser.get_parse_tree_declarations_in_range(section.second);
+            for (auto& decl : decls) {
+                assert(decl);
+                emit(*decl);
+            }
+        }
+
+        if (cpp1_filename.back() == 'h') {
+            printer.print_extra( "\n#endif" );
+        }
+
+        printer.finalize_phase( true );
+
+        //  Finally, some debug checks
+        assert(
+            (!errors.empty() || tokens.num_unprinted_comments() == 0)
+            && "ICE: not all comments were printed"
+        );
+
+        return ret;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    //  emit() functions - each emits a kind of node
+    //
+    //  The body often mirrors the node's visit() function, unless customization
+    //  is needed where Cpp1 and Cpp2 have different grammar orders
+    //
+
+    void print_to_string(
+        std::string* str,
+        auto&        i,
+        auto...      more
+    )
+    {
+        //  Quick special-purpose state preservation... this tactical hack
+        //  is fine for now, but if needed more then generalize this
+        auto state1 = need_expression_list_parens;
+        auto state2 = already_moved_that_members;
+
+        printer.emit_to_string(str);
+        emit(i, more...);
+        printer.emit_to_string();
+
+        //  Restore state
+        need_expression_list_parens.swap(state1);
+        already_moved_that_members .swap(state2);
+    };
+
+    auto print_to_string(
+        auto&   i,
+        auto... more
+    )
+        -> std::string
+    {
+        auto print = std::string{};
+        print_to_string(&print, i, more...);
+        return print;
+    };
+
+    //-----------------------------------------------------------------------
+    //  try_emit
+    //
+    //  Helper to emit whatever is in a variant where each
+    //  alternative is a smart pointer
+    //
+    template <int I>
+    auto try_emit(
+        auto&     v,
+        auto&&... more
+    )
+        -> void
+    {
+        if (v.index() == I) {
+            auto const& alt = std::get<I>(v);
+            assert (alt);
+            emit (*alt, CPP2_FORWARD(more)...);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        token const&    n,
+        bool            is_qualified = false,
+        source_position pos          = {}
+    )
+        -> void
+    {   STACKINSTR
+        if (pos == source_position{}) {
+            pos = n.position();
+        }
+
+        //  Implicit "cpp2::" qualification of Cpp2 fixed-width type aliases
+        //  and cpp2::finally
+        if (
+            !is_qualified
+            && (
+                n.type() == lexeme::Cpp2FixedType
+                || n == "finally"
+                )
+            )
+        {
+            printer.print_cpp2("cpp2::", pos);
+        }
+
+        //  'this' is not a pointer
+        if (n == "this") {
+            printer.print_cpp2("(*this)", pos);
+        }
+        //  Reclaim the alternative names and some keywords for users
+        else if (
+            n == "and"
+            || n == "and_eq"
+            || n == "bitand"
+            || n == "bitor"
+            || n == "compl"
+            || n == "not"
+            || n == "not_eq"
+            || n == "or"
+            || n == "or_eq"
+            || n == "xor"
+            || n == "xor_eq"
+            || n == "new"
+            || n == "class"
+            || n == "struct"
+            || n == "enum"
+            || n == "union"
+            )
+        {
+            printer.print_cpp2("cpp2_"+n.to_string(), pos);
+        }
+        else {
+            printer.print_cpp2(n, pos, true);
+        }
+
+        in_definite_init = is_definite_initialization(&n);
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        literal_node const& n,
+        source_position     pos = {}
+    )
+        -> void
+    {   STACKINSTR
+        if (pos == source_position{}) {
+            pos = n.position();
+        }
+
+        assert(n.literal);
+        emit(*n.literal);
+        if (n.user_defined_suffix) {
+            emit(*n.user_defined_suffix);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        unqualified_id_node const& n,
+        bool in_synthesized_multi_return = false,
+        bool is_local_name = true,
+        bool is_qualified = false
+    )
+        -> void
+    {   STACKINSTR
+        auto last_use = is_definite_last_use(n.identifier);
+
+        bool add_forward =
+            last_use
+            && last_use->is_forward
+            && !in_non_rvalue_context.back();
+
+        bool add_move =
+            !add_forward
+            && (
+                in_synthesized_multi_return
+                || (last_use && !suppress_move_from_last_use)
+                )
+            && !in_non_rvalue_context.back();
+
+        if (
+            add_move
+            && *(n.identifier - 1) == "return"
+            && *(n.identifier + 1) == ";"
+            )
+        {
+            add_move = false;
+        }
+
+        if (
+            emitting_move_that_function
+            && *n.identifier == "that"
+            )
+        {
+            add_move = true;
+        }
+
+        //  For an explicit 'forward' apply forwarding to correct identifier
+        assert (!current_args.empty());
+        if (current_args.back().pass == passing_style::forward) {
+            add_forward = current_args.back().ptoken == n.identifier;
+        }
+
+        if (add_move) {
+            printer.print_cpp2("std::move(", n.position());
+        }
+        if (add_forward) {
+            printer.print_cpp2("CPP2_FORWARD(", {n.position().lineno, n.position().colno - 8});
+        }
+
+        assert(n.identifier);
+        emit(*n.identifier, is_qualified);  // inform the identifier if we know this is qualified
+
+        if (n.open_angle != source_position{}) {
+            printer.print_cpp2("<", n.open_angle);
+            auto first = true;
+            for (auto& a : n.template_args) {
+                if (!first) {
+                    printer.print_cpp2(",", a.comma);
+                }
+                first = false;
+                try_emit<template_argument::expression>(a.arg);
+                try_emit<template_argument::type_id   >(a.arg);
+            }
+            printer.print_cpp2(">", n.close_angle);
+        }
+
+        in_definite_init = is_definite_initialization(n.identifier);
+        if (
+            !in_definite_init
+            && !in_parameter_list
+            )
+        {
+            if (auto decl = sema.get_declaration_of(*n.identifier);
+                is_local_name
+                && !(*n.identifier == "this")
+                && !(*n.identifier == "that")
+                && decl
+                && (
+                    in_synthesized_multi_return
+                    //  note pointer equality: if we're not in the actual declaration of n.identifier
+                    || decl->identifier != n.identifier
+                    )
+                //  and this variable was uninitialized
+                && !decl->initializer
+                //  and it's either a non-parameter or an out parameter
+                && (
+                    !decl->parameter
+                    || (
+                        decl->parameter
+                        && decl->parameter->pass == passing_style::out
+                        )
+                    )
+                )
+            {
+                printer.print_cpp2(".value()", n.position());
+            }
+        }
+        else if (in_synthesized_multi_return) {
+            printer.print_cpp2(".value()", n.position());
+        }
+
+        if (
+            add_move
+            || add_forward
+            )
+        {
+            printer.print_cpp2(")", n.position());
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        qualified_id_node const& n,
+        bool include_unqualified_id = true
+        )
+        -> void
+    {   STACKINSTR
+        if (!sema.check(n)) {
+            return;
+        }
+
+        //  Implicit "cpp2::" qualification of "unique.new" and "shared.new"
+        if (
+            n.ids.size() == 2
+            && (
+                *n.ids[0].id->identifier == "unique"
+                || *n.ids[0].id->identifier == "shared"
+                )
+            && *n.ids[1].scope_op == "."
+            && *n.ids[1].id->identifier == "new"
+            )
+        {
+            printer.print_cpp2("cpp2::", n.position());
+        }
+
+        auto ident = std::string{};
+        printer.emit_to_string(&ident);
+
+        for (auto const& id : std::span{n.ids}.first(n.ids.size() - !include_unqualified_id))
+        {
+            if (id.scope_op) {
+                emit(*id.scope_op);
+            }
+            emit(*id.id, false, true, true);    // inform the unqualified-id that it's qualified
+        }
+
+        printer.emit_to_string();
+        printer.print_cpp2( ident, n.position() );
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        type_id_node const& n,
+        source_position     pos = {}
+    )
+        -> void
+    {   STACKINSTR
+        if (pos == source_position{}) {
+            pos = n.position();
+        }
+
+        if (n.is_wildcard()) {
+            printer.print_cpp2("auto", pos);
+        }
+        else {
+            try_emit<type_id_node::unqualified>(n.id, false, false);
+            try_emit<type_id_node::qualified  >(n.id);
+            try_emit<type_id_node::keyword    >(n.id);
+        }
+
+        for (auto i = n.pc_qualifiers.rbegin(); i != n.pc_qualifiers.rend(); ++i) {
+            if ((**i) == "const") { printer.print_cpp2(" ", pos); }
+            emit(**i, false, pos);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        id_expression_node const& n,
+        bool                      is_local_name          = true
+    )
+        -> void
+    {   STACKINSTR
+        try_emit<id_expression_node::qualified  >(n.id);
+        try_emit<id_expression_node::unqualified>(n.id, false, is_local_name);
+    }
+
+
+    auto emit_prolog_mem_inits(
+        function_prolog const& prolog,
+        colno_t                indent
+    )
+        -> void
+    {   STACKINSTR
+        for (auto& line : prolog.mem_inits) {
+            printer.print_extra("\n");
+            printer.print_extra(pad(indent-1));
+            printer.print_extra(line);
+        }
+    }
+
+    auto emit_prolog_statements(
+        function_prolog const& prolog,
+        colno_t                indent
+    )
+        -> void
+    {   STACKINSTR
+        for (auto& line : prolog.statements) {
+            printer.print_extra("\n");
+            printer.print_extra(pad(indent-1));
+            printer.print_extra(line);
+        }
+    }
+
+    auto emit_epilog_statements(
+        std::vector<std::string> const& epilog,
+        colno_t                         indent
+    )
+        -> void
+    {   STACKINSTR
+        for (auto& line : epilog) {
+            printer.print_extra("\n");
+            printer.print_extra(pad(indent-1));
+            printer.print_extra(line);
+        }
+    }
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        compound_statement_node  const&  n,
+        function_prolog          const& function_prolog = {},
+        std::vector<std::string> const& function_epilog = {}
+    )
+        -> void
+    {   STACKINSTR
+        emit_prolog_mem_inits(function_prolog, n.body_indent+1);
+
+        printer.print_cpp2( "{", n.open_brace );
+
+        emit_prolog_statements(function_prolog, n.body_indent+1);
+
+        for (auto const& x : n.statements) {
+            assert(x);
+            emit(*x);
+        }
+
+        emit_epilog_statements( function_epilog, n.body_indent+1);
+
+        printer.print_cpp2( "}", n.close_brace );
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        inspect_expression_node const& n,
+        bool                           is_expression
+    )
+        -> void
+    {   STACKINSTR
+        auto constexpr_qualifier = std::string{};
+        if (n.is_constexpr) {
+            constexpr_qualifier = "constexpr ";
+        }
+
+        //  If this is an expression, it will have an explicit result type,
+        //  and we need to start the lambda that we'll immediately invoke
+        auto result_type = std::string{};
+        if (is_expression) {
+            assert(n.result_type);
+            printer.emit_to_string(&result_type);
+            emit(*n.result_type);
+            printer.emit_to_string();
+            printer.print_cpp2("[&] () -> " + result_type + " ", n.position());
+        }
+        printer.print_cpp2("{ " + constexpr_qualifier + "auto&& _expr = ", n.position());
+
+        assert(n.expression);
+        emit(*n.expression);
+        printer.print_cpp2(";", n.position());
+
+        assert(
+            n.identifier
+            && *n.identifier == "inspect"
+        );
+
+        assert(!n.alternatives.empty());
+        auto found_wildcard = false;
+
+        for (auto first = true; auto&& alt : n.alternatives)
+        {
+            assert(alt && alt->is_as_keyword);
+            if (!first) {
+                printer.print_cpp2("else ", alt->position());
+            }
+            first = false;
+
+            auto id = std::string{};
+            printer.emit_to_string(&id);
+
+            if (alt->type_id) {
+                emit(*alt->type_id);
+            }
+            else {
+                assert(alt->value);
+                emit(*alt->value);
+            }
+            printer.emit_to_string();
+
+            assert (
+                *alt->is_as_keyword == "is"
+                || *alt->is_as_keyword == "as"
+            );
+            // TODO: pick up 'as' next, for now just do 'is'
+
+            if (*alt->is_as_keyword == "is")
+            {
+                //  Stringize the expression-statement now...
+                auto statement = std::string{};
+                printer.emit_to_string(&statement);
+                emit(*alt->statement);
+                printer.emit_to_string();
+                //  ... and jettison the final ; for an expression-statement
+                while (
+                    !statement.empty()
+                    && (
+                        statement.back() == ';'
+                        || isspace(statement.back())
+                        )
+                    )
+                {
+                    statement.pop_back();
+                }
+
+                replace_all( statement, "cpp2::as_<", "cpp2::as<" );
+
+                //  If this is an inspect-expression, we'll have to wrap each alternative
+                //  in an 'if constexpr' so that its type is ignored for mismatches with
+                //  the inspect-expression's type
+                auto return_prefix = std::string{};
+                auto return_suffix = std::string{";"};   // use this to tack the ; back on in the alternative body
+                if (is_expression) {
+                    return_prefix = "{ if constexpr( requires{" + statement + ";} ) if constexpr( std::is_convertible_v<CPP2_TYPEOF((" + statement + "))," + result_type + "> ) return ";
+                    return_suffix += " }";
+                }
+
+                if (id == "auto") {
+                    found_wildcard = true;
+                    if (is_expression) {
+                        printer.print_cpp2("return ", alt->position());
+                    }
+                }
+                else {
+                    printer.print_cpp2("if " + constexpr_qualifier, alt->position());
+                    if (alt->type_id) {
+                        printer.print_cpp2("(cpp2::is<" + id + ">(_expr)) ", alt->position());
+                    }
+                    else {
+                        assert (alt->value);
+                        printer.print_cpp2("(cpp2::is(_expr, " + id + ")) ", alt->position());
+                    }
+                    printer.print_cpp2(return_prefix, alt->position());
+                }
+
+                printer.print_cpp2(statement, alt->position());
+
+                if (
+                    is_expression
+                    && id != "auto"
+                    )
+                {
+                    assert(alt->statement->is_expression());
+                    printer.print_cpp2("; else return " + result_type + "{}", alt->position());
+                    printer.print_cpp2("; else return " + result_type + "{}", alt->position());
+                }
+
+                printer.print_cpp2(return_suffix, alt->position());
+            }
+            else {
+                errors.emplace_back(
+                    alt->position(),
+                    "(temporary alpha limitation) cppfront is still learning 'inspect' - only simple 'is' alternatives are currently supported"
+                );
+                return;
+            }
+        }
+
+        if (is_expression) {
+            if (!found_wildcard) {
+                errors.emplace_back(
+                    n.position(),
+                    "an inspect expression must have an `is _` match-anything wildcard alternative"
+                );
+                return;
+            }
+        }
+        else {
+            printer.print_cpp2("}", n.close_brace);
+        }
+
+        //  If this is an expression, finally actually invoke the lambda
+        if (is_expression) {
+            printer.print_cpp2("()", n.close_brace);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(selection_statement_node const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.identifier);
+        emit(*n.identifier);
+
+        if (n.is_constexpr) {
+            printer.print_cpp2(" constexpr", n.position());
+        }
+
+        printer.print_cpp2(" (", n.position());
+        printer.add_pad_in_this_line(1);
+
+        assert(n.expression);
+        emit(*n.expression);
+
+        printer.print_cpp2(") ", n.position());
+        printer.add_pad_in_this_line(1);
+
+        assert(n.true_branch);
+        emit(*n.true_branch);
+
+        if (n.has_source_false_branch) {
+            printer.print_cpp2("else ", n.else_pos);
+            emit(*n.false_branch);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(iteration_statement_node const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.identifier);
+        in_non_rvalue_context.push_back(true);
+        auto guard = finally([&]{ in_non_rvalue_context.pop_back(); });
+
+        iteration_statements.push_back({ &n, false});
+        auto labelname = labelized_position(n.label);
+
+        //  Handle while
+        //
+        if (*n.identifier == "while") {
+            assert(
+                n.condition
+                && n.statements
+                && !n.range
+                && !n.body
+            );
+
+            //  We emit Cpp2 while loops as Cpp2 for loops if there's a "next" clause
+            if (!n.next_expression) {
+                printer.print_cpp2("while( ", n.position());
+                emit(*n.condition);
+            }
+            else {
+                printer.print_cpp2("for( ; ", n.position());
+                emit(*n.condition);
+                printer.print_cpp2("; ", n.position());
+                printer.add_pad_in_this_line(-10);
+                emit(*n.next_expression);
+            }
+            printer.print_cpp2(" ) ", n.position());
+            if (!labelname.empty()) {
+                printer.print_extra("{");
+            }
+            emit(*n.statements);
+            if (!labelname.empty()) {
+                printer.print_extra(" CPP2_CONTINUE_BREAK("+labelname+") }");
+            }
+        }
+
+        //  Handle do
+        //
+        else if (*n.identifier == "do") {
+            assert(
+                n.condition
+                && n.statements
+                && !n.range
+                && !n.body
+            );
+
+            printer.print_cpp2("do ", n.position());
+            if (!labelname.empty()) {
+                printer.print_extra("{");
+            }
+            emit(*n.statements);
+            if (!labelname.empty()) {
+                printer.print_extra(" CPP2_CONTINUE_BREAK("+labelname+") }");
+            }
+            printer.print_cpp2(" while ( ", n.position());
+            if (n.next_expression) {
+                //  Gotta say, this feels kind of nifty... short-circuit eval
+                //  and smuggling work into a condition via a lambda, O my...
+                printer.print_cpp2("[&]{ ", n.position());
+                emit(*n.next_expression);
+                printer.print_cpp2(" ; return true; }() && ", n.position());
+            }
+            emit(*n.condition);
+            printer.print_cpp2(");", n.position());
+        }
+
+        //  Handle for
+        //
+        else if (*n.identifier == "for") {
+            assert(
+                !n.condition
+                && !n.statements
+                && n.range
+                && n.parameter
+                && n.body
+            );
+
+            //  Note: This used to emit cpp2_range as a range-for-loop scope variable,
+            //        but some major compilers seem to have random troubles with that;
+            //        the workaround to avoid their bugs for now is to emit a { } block
+            //        around the Cpp1 range-for and make the scope variable a normal local
+
+            printer.print_cpp2("for ( ", n.position());
+
+            emit(*n.parameter);
+
+            printer.print_cpp2(" : ", n.position());
+
+            //  If this expression is just a single expression-list, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (n.range->is_expression_list()) {
+                printer.print_cpp2( "{ ", n.position() );
+                emit(*n.range->get_expression_list(), false);
+                printer.print_cpp2( " }", n.position() );
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*n.range);
+            }
+
+            printer.print_cpp2(" ) ", n.position());
+            if (!labelname.empty()) {
+                printer.print_extra("{");
+            }
+
+            //  If there's a next-expression, smuggle it in via a nested do/while(false) loop
+            //  (nested "continue" will work, but "break" won't until we do extra work to implement
+            //  that using a flag and implementing "break" as "_for_break = true; continue;")
+            if (n.next_expression) {
+                printer.print_cpp2(" { do ", n.position());
+            }
+
+            assert(n.body);
+            emit(*n.body);
+
+            if (n.next_expression) {
+                printer.print_cpp2(" while (false); ", n.position());
+                emit(*n.next_expression);
+                printer.print_cpp2("; }", n.position());
+            }
+
+            printer.print_cpp2("", n.position());
+            if (!labelname.empty()) {
+                printer.print_extra(" CPP2_CONTINUE_BREAK("+labelname+") }");
+            }
+        }
+
+        else {
+            assert(!"ICE: unexpected case");
+        }
+
+        assert (iteration_statements.back().stmt);
+        if (
+            iteration_statements.back().stmt->label
+            && !iteration_statements.back().used
+            )
+        {
+            auto name = iteration_statements.back().stmt->label->to_string();
+            errors.emplace_back(
+                iteration_statements.back().stmt->position(),
+                name + ": a named loop must have its name used (did you forget 'break " + name + ";' or 'continue " + name + "';?)"
+            );
+        }
+
+        iteration_statements.pop_back();
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(return_statement_node const& n)
+        -> void
+    {   STACKINSTR
+        assert (!current_functions.empty());
+        if (current_functions.back().func->has_postconditions()) {
+            printer.print_cpp2( "cpp2_finally_presuccess.run(); ", n.position() );
+        }
+
+        assert(n.identifier);
+        assert(*n.identifier == "return");
+        printer.print_cpp2("return ", n.position());
+
+        //  Return with expression == single anonymous return type
+        //
+        if (n.expression)
+        {
+            assert(!current_functions.empty());
+            auto is_forward_return =
+                !function_returns.empty()
+                && function_returns.back().pass == passing_style::forward;
+            auto is_deduced_return =
+                !function_returns.empty()
+                && function_returns.back().is_deduced;
+
+            //  If we're doing a forward return of a single-token name
+            if (auto tok = n.expression->expr->get_postfix_expression_node()->expr->get_token();
+                tok
+                && is_forward_return
+                )
+            {
+                //  Ensure we're not returning a local or an in/move parameter
+                auto is_parameter_name = current_functions.back().decl->has_parameter_named(*tok);
+                if (
+                    is_parameter_name
+                    && (
+                        current_functions.back().decl->has_in_parameter_named(*tok)
+                        || current_functions.back().decl->has_move_parameter_named(*tok)
+                        )
+                    )
+                {
+                    errors.emplace_back(
+                        n.position(),
+                        "a 'forward' return type cannot return an 'in' or 'move' parameter"
+                    );
+                    return;
+                }
+                else if (
+                    !is_parameter_name
+                    && sema.get_declaration_of(*tok)
+                    )
+                {
+                    errors.emplace_back(
+                        n.position(),
+                        "a 'forward' return type cannot return a local variable"
+                    );
+                    return;
+                } else if (
+                    is_literal(tok->type()) || n.expression->expr->is_result_a_temporary_variable()
+                )
+                {
+                    errors.emplace_back(
+                        n.position(),
+                        "a 'forward' return type cannot return a temporary variable"
+                    );
+                    return;
+                }
+            }
+
+            //  If this expression is just a single expression-list, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (n.expression->is_expression_list()) {
+                if (!is_deduced_return) {
+                    printer.print_cpp2( "{ ", n.position() );
+                }
+                emit(*n.expression->get_expression_list(), false);
+                if (!is_deduced_return) {
+                    printer.print_cpp2( " }", n.position() );
+                }
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*n.expression);
+            }
+
+            if (
+                function_returns.empty()
+                || function_returns.back().param_list != &single_anon
+                )
+            {
+                errors.emplace_back(
+                    n.position(),
+                    "return statement with expression must be in a function with a single anonymous return value"
+                );
+                return;
+            }
+        }
+
+        else if (
+            !function_returns.empty()
+            && function_returns.back().param_list == &single_anon
+            )
+        {
+            errors.emplace_back(
+                n.position(),
+                "return statement must have an expression in a function with a single anonymous return value"
+            );
+        }
+
+        //  Return without expression, could be assignment operator
+        //
+        else if (generating_assignment_from == current_functions.back().decl)
+        {
+            printer.print_cpp2("*this", n.position());
+        }
+
+        //  Otherwise, zero or named return values
+        //
+        else if (
+            !function_returns.empty()
+            && function_returns.back().param_list
+            )
+        {
+            auto& parameters = function_returns.back().param_list->parameters;
+
+            auto stmt = std::string{};
+
+            //  Put braces only around multiple named returns, which are a struct
+            //  - single named returns are emitted as ordinary returns, and extra
+            //  { } would be legal but generate a noisy warning on some compilers
+            if (std::ssize(parameters) > 1) {
+                stmt += std::string(" { ");
+            }
+
+            for (bool first = true; auto& param : parameters) {
+                if (!first) {
+                    stmt += ", ";
+                }
+                first = false;
+                assert(param->declaration->identifier);
+
+                printer.emit_to_string(&stmt);
+                emit(*param->declaration->identifier, true);
+                printer.emit_to_string();
+            }
+
+            if (std::ssize(parameters) > 1) {
+                stmt += std::string(" }");
+            }
+
+            printer.print_cpp2(stmt, n.position());
+        }
+
+        printer.print_cpp2("; ", n.position());
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(jump_statement_node const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.keyword);
+
+        if (n.label) {
+            auto iter_stmt =
+                std::find_if(
+                    iteration_statements.begin(),
+                    iteration_statements.end(),
+                    [&](auto& s){
+                        assert(s.stmt);
+                        return
+                            s.stmt->label
+                            && std::string_view{*s.stmt->label} == std::string_view{*n.label}
+                            ;
+                    }
+                );
+            if (iter_stmt == iteration_statements.end())
+            {
+                errors.emplace_back(
+                    n.position(),
+                    "a named " + n.keyword->to_string() + " must use the name of an enclosing local loop label"
+                );
+                return;
+            }
+            iter_stmt->used = true;
+            assert((*iter_stmt).stmt->label);
+            printer.print_cpp2(
+                "goto " + to_upper_and_underbar(*n.keyword) + "_" + labelized_position((*iter_stmt).stmt->label) + ";",
+                n.position()
+            );
+        }
+        else {
+            emit(*n.keyword);
+            printer.print_cpp2(";", n.position());
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(using_statement_node const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.keyword);
+        emit(*n.keyword);
+
+        if (n.for_namespace) {
+            printer.print_cpp2(" namespace", n.position());
+        } else {
+            current_names.push_back(active_using_declaration{n});
+        }
+
+        printer.print_cpp2(" " + print_to_string(*n.id) + ";", n.position());
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto build_capture_lambda_intro_for(
+        capture_group&  captures,
+        source_position pos,
+        bool            include_default_reference_capture = false
+    )
+        -> std::string
+    {
+        //  First calculate the stringized version of each capture expression
+        //  This will let us compare and de-duplicate repeated capture expressions
+        for (auto& cap : captures.members)
+        {
+            assert(cap.capture_expr->cap_grp == &captures);
+            if (cap.str.empty()) {
+                print_to_string(&cap.str, *cap.capture_expr, true);
+                suppress_move_from_last_use = true;
+                print_to_string(&cap.str_suppressed_move, *cap.capture_expr, true);
+                suppress_move_from_last_use = false;
+            }
+        }
+
+        // If move from last use was used on the variable we need to rewrite the str to add std::move
+        // to earlier use of the variable. That will save us from capturing one variable two times
+        // (one with copy and one with std::move).
+        for (auto rit = captures.members.rbegin(); rit != captures.members.rend(); ++rit)
+        {
+            auto is_same_str_suppressed_move = [s=rit->str_suppressed_move](auto& cap){
+                return cap.str_suppressed_move == s;
+            };
+
+            auto rit2 = std::find_if(rit+1, captures.members.rend(), is_same_str_suppressed_move);
+            while (rit2 != captures.members.rend())
+            {
+                rit2->str = rit->str;
+                rit2 = std::find_if(rit2+1, captures.members.rend(), is_same_str_suppressed_move);
+            }
+        }
+
+        //  Then build the capture list, ignoring duplicated expressions
+        auto lambda_intro = std::string("[");
+        auto num_captures = 0;
+
+        if (
+            (!current_functions.empty()
+                && current_functions.back().decl->is_function_with_this()
+                && !current_functions.back().decl->parent_is_namespace()
+                )
+            || include_default_reference_capture
+            )
+        {
+            //  Note: & is needed (when allowed, not at namespace scope) because a
+            //  nested UFCS might be viewed as trying to capture 'this'
+            lambda_intro += "&";
+            ++num_captures;
+        }
+
+        printer.emit_to_string(&lambda_intro);
+
+        auto handled = std::vector<std::string>{};
+        for (auto& cap : captures.members)
+        {
+            //  If we haven't handled a capture that looks like this one
+            if (std::find(handled.begin(), handled.end(), cap.str) == handled.end())
+            {
+                //  Remember it
+                handled.push_back(cap.str);
+
+                //  And handle it
+                if (num_captures != 0) { // not first
+                    lambda_intro += ", ";
+                }
+                cap.cap_sym = "_"+std::to_string(num_captures);
+                printer.print_cpp2(cap.cap_sym + " = " + cap.str, pos);
+            }
+            ++num_captures;
+        }
+        printer.emit_to_string();
+        lambda_intro += "]";
+
+        return lambda_intro;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(primary_expression_node const& n)
+        -> void
+    {   STACKINSTR
+        try_emit<primary_expression_node::identifier     >(n.expr);
+        try_emit<primary_expression_node::expression_list>(n.expr);
+        try_emit<primary_expression_node::id_expression  >(n.expr);
+        try_emit<primary_expression_node::inspect        >(n.expr, true);
+        try_emit<primary_expression_node::literal        >(n.expr);
+
+        if (n.expr.index() == primary_expression_node::declaration)
+        {
+            //  This must be an anonymous declaration
+            auto& decl = std::get<primary_expression_node::declaration>(n.expr);
+            assert(
+                decl
+                && !decl->identifier
+            );
+
+            //  Handle an anonymous function
+            if (decl->is_function()) {
+                auto lambda_intro = build_capture_lambda_intro_for(decl->captures, n.position());
+
+                // Handle an anonymous generic function with explicit type list
+                if (decl->template_parameters) {
+                    print_to_string(&lambda_intro, *decl->template_parameters, false, true);
+                }
+
+                emit(*decl, lambda_intro);
+            }
+            //  Else an anonymous object as 'typeid { initializer }'
+            else {
+                assert(decl->is_object());
+                auto& type_id = std::get<declaration_node::an_object>(decl->type);
+
+                printer.add_pad_in_this_line( -5 );
+
+                emit(*type_id);
+                printer.print_cpp2("{", decl->position());
+
+                if (!decl->initializer) {
+                    errors.emplace_back(
+                        decl->position(),
+                        "an anonymous object declaration must have '=' and an initializer"
+                    );
+                    return;
+                }
+
+                emit(*decl->initializer, false);
+
+                printer.print_cpp2("}", decl->position());
+            }
+        }
+    }
+
+    //  Not yet implemented. TODO: finalize deducing pointer types from parameter lists
+    auto is_pointer_declaration(
+        parameter_declaration_list_node const*,
+        int,
+        int
+    )
+        -> bool
+    {
+        return false;
+    }
+
+    auto is_pointer_declaration(
+        declaration_node const* decl_node,
+        int                     deref_cnt,
+        int                     addr_cnt
+    )
+        -> bool
+    {
+        if (!decl_node) {
+            return false;
+        }
+        if (addr_cnt > deref_cnt) {
+            return true;
+        }
+
+        return std::visit([&](auto const& type){
+            return is_pointer_declaration(type.get(), deref_cnt, addr_cnt);
+        }, decl_node->type);
+    }
+
+    auto is_pointer_declaration(
+        function_type_node const* fun_node,
+        int                       deref_cnt,
+        int                       addr_cnt
+    )
+        -> bool
+    {
+        if (!fun_node) {
+            return false;
+        }
+        if (addr_cnt > deref_cnt) {
+            return true;
+        }
+
+        return std::visit([&]<typename T>(T const& type){
+            if constexpr (std::is_same_v<T, std::monostate>) {
+                return false;
+            }
+            else if constexpr (std::is_same_v<T, function_type_node::single_type_id>) {
+                return is_pointer_declaration(type.type.get(),  deref_cnt, addr_cnt);
+            }
+            else {
+                return is_pointer_declaration(type.get(),  deref_cnt, addr_cnt);
+            }
+        }, fun_node->returns);
+    }
+
+    auto is_pointer_declaration(
+        type_id_node const* type_id_node,
+        int                 deref_cnt,
+        int                 addr_cnt
+    )
+        -> bool
+    {
+        if (!type_id_node) {
+            return false;
+        }
+        if (addr_cnt > deref_cnt) {
+            return true;
+        }
+
+        if ( type_id_node->dereference_of ) {
+            return is_pointer_declaration(type_id_node->dereference_of, deref_cnt + type_id_node->dereference_cnt, addr_cnt);
+        } else if ( type_id_node->address_of ) {
+            return is_pointer_declaration(type_id_node->address_of, deref_cnt, addr_cnt + 1);
+        }
+
+        int pointer_declarators_cnt = std::count_if(std::cbegin(type_id_node->pc_qualifiers), std::cend(type_id_node->pc_qualifiers), [](auto* q) {
+            return q->type() == lexeme::Multiply;
+        });
+
+        if (
+            pointer_declarators_cnt == 0
+            && type_id_node->suspicious_initialization
+            )
+        {
+            return is_pointer_declaration(type_id_node->suspicious_initialization, deref_cnt, addr_cnt);
+        }
+
+        return (pointer_declarators_cnt + addr_cnt - deref_cnt) > 0;
+    }
+
+    auto is_pointer_declaration(
+        type_node const*,
+        int,
+        int
+    )
+        -> bool
+    {
+        return false;
+    }
+
+    auto is_pointer_declaration(
+        namespace_node const*,
+        int,
+        int
+    )
+        -> bool
+    {
+        return false;
+    }
+
+    auto is_pointer_declaration(
+        alias_node const*,
+        int,
+        int
+    )
+        -> bool
+    {
+        return false;
+    }
+
+    auto is_pointer_declaration(
+        declaration_sym const* decl,
+        int                    deref_cnt,
+        int                    addr_cnt
+    )
+        -> bool
+    {
+        if (!decl) {
+            return false;
+        }
+        if (addr_cnt > deref_cnt) {
+            return true;
+        }
+        return is_pointer_declaration(decl->declaration, deref_cnt, addr_cnt);
+    }
+
+    auto is_pointer_declaration(
+        token const* t,
+        int          deref_cnt = 0,
+        int          addr_cnt = 0
+    )
+        -> bool
+    {
+        if (!t) {
+            return false;
+        }
+        if (addr_cnt > deref_cnt) {
+            return true;
+        }
+        auto decl = sema.get_declaration_of(*t, true);
+        return is_pointer_declaration(decl, deref_cnt, addr_cnt);
+    }
+
+
+    auto source_order_name_lookup(unqualified_id_node const& id)
+    -> source_order_name_lookup_res
+    {
+        for (
+            auto first = current_names.rbegin(), last = current_names.rend() - 1;
+            first != last;
+            ++first
+            )
+        {
+            if (
+                auto decl = get_if<declaration_node const*>(&*first);
+                decl
+                && *decl
+                && (*decl)->has_name(*id.identifier)
+                )
+            {
+                return *decl;
+            }
+            else if (
+                auto using_ = get_if<active_using_declaration>(&*first);
+                using_
+                && using_->identifier
+                && *using_->identifier == *id.identifier
+                )
+            {
+                return *using_;
+            }
+        }
+
+        return {};
+    }
+
+
+    auto lookup_finds_variable_with_placeholder_type_under_initialization(id_expression_node const& n)
+        -> bool
+    {
+        if (!n.is_unqualified())
+        {
+            return false;
+        }
+
+        auto const& id = *get<id_expression_node::unqualified>(n.id);
+        auto lookup = source_order_name_lookup(id);
+
+        if (
+            !lookup
+            || get_if<active_using_declaration>(&*lookup)
+            )
+        {
+            return false;
+        }
+
+        auto decl = get<declaration_node const*>(*lookup);
+        if (
+            decl
+            && decl->has_name(*id.identifier)
+            )
+        {
+            if (
+                !decl->is_object()
+                && !decl->is_object_alias()
+                )
+            {
+                return false;
+            }
+
+            if (decl->is_object()) {
+                auto type = &**get_if<declaration_node::an_object>(&decl->type);
+                return type->is_wildcard()
+                       && contains(current_declarations, decl);
+            }
+            auto const& type = (**get_if<declaration_node::an_alias>(&decl->type)).type_id;
+            return (
+                    !type
+                    || type->is_wildcard()
+                    )
+                   && contains(current_declarations, decl);
+        }
+
+        return false;
+    }
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        //  Note: parameter is not const as we'll fill in the capture .str info
+        postfix_expression_node& n,
+        bool                     for_lambda_capture = false
+    )
+        -> void
+    {   STACKINSTR
+        if (!sema.check(n)) {
+            return;
+        }
+
+        assert(n.expr);
+        last_postfix_expr_was_pointer = false;
+
+        //  For a 'move that' parameter, track the members we already moved from
+        //  so we can diagnose attempts to move from the same member twice
+        if (
+            emitting_move_that_function
+            && n.expr->get_token()
+            && *n.expr->get_token() == "that"
+            )
+        {
+            if (n.ops.empty()) {
+                if (!already_moved_that_members.empty()) {
+                    errors.emplace_back(
+                        n.position(),
+                        "attempting to move from whole 'that' object after a 'that.member' was already moved from"
+                    );
+                    return;
+                }
+                //  push a sentinel for "all members"
+                already_moved_that_members.push_back(nullptr);
+            }
+            else {
+                auto member = n.ops[0].id_expr->get_token();
+                assert(member);
+
+                for (
+                    auto i = already_moved_that_members.begin();
+                    i != already_moved_that_members.end();
+                    ++i
+                    )
+                {
+                    if (
+                        !*i
+                        || **i == *member
+                        )
+                    {
+                        errors.emplace_back(
+                            n.position(),
+                            "attempting to move twice from 'that." + member->to_string() + "'"
+                        );
+                        return;
+                    }
+                }
+
+                already_moved_that_members.push_back(member);
+            }
+        }
+
+        //  Ensure that forwarding postfix-expressions start with a forwarded parameter name
+        //
+        assert (!current_args.empty());
+        if (current_args.back().pass == passing_style::forward)
+        {
+            assert (n.expr->get_token());
+            assert (!current_args.back().ptoken);
+            current_args.back().ptoken = n.expr->get_token();
+            auto decl = sema.get_declaration_of(*current_args.back().ptoken);
+            if (!(decl && decl->parameter && decl->parameter->pass == passing_style::forward))
+            {
+                errors.emplace_back(
+                    n.position(),
+                    n.expr->get_token()->to_string() + " is not a forwarding parameter name"
+                );
+            }
+        }
+
+        //  Check that this isn't pointer arithmentic
+        //      (initial partial implementation)
+        if (n.expr->expr.index() == primary_expression_node::id_expression)
+        {
+            auto& id = std::get<primary_expression_node::id_expression>(n.expr->expr);
+            assert(id);
+            if (id->id.index() == id_expression_node::unqualified)
+            {
+                auto& unqual = std::get<id_expression_node::unqualified>(id->id);
+                assert(unqual);
+                //  TODO: Generalize this:
+                //        - we don't recognize pointer types from Cpp1
+                //        - we don't deduce pointer types from parameter_declaration_list_node
+                if ( is_pointer_declaration(unqual->identifier) ) {
+                    if (n.ops.empty()) {
+                        last_postfix_expr_was_pointer = true;
+                    }
+                    else
+                    {
+                        auto op = [&]{
+                            if (
+                                n.ops.size() >= 2
+                                && n.ops[0].op->type() == lexeme::LeftParen
+                                )
+                            {
+                                return n.ops[1].op;
+                            }
+                            else
+                            {
+                                return n.ops.front().op;
+                            }
+                        }();
+
+                        if (
+                            op->type() == lexeme::PlusPlus
+                            || op->type() == lexeme::MinusMinus
+                            || op->type() == lexeme::LeftBracket
+                            )
+                        {
+                            errors.emplace_back(
+                                op->position(),
+                                op->to_string() + " - pointer arithmetic is illegal - use std::span or gsl::span instead"
+                            );
+                            violates_bounds_safety = true;
+                        }
+                        else if (
+                            op->type() == lexeme::Tilde
+                            )
+                        {
+                            errors.emplace_back(
+                                op->position(),
+                                op->to_string() + " - pointer bitwise manipulation is illegal - use std::bit_cast to convert to raw bytes first"
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        //  Simple case: If there are no .ops, just emit the expression
+        if (n.ops.empty()) {
+            emit(*n.expr);
+            return;
+        }
+
+        //  Check to see if it's a capture expression that contains $,
+        //  and if we're not capturing the expression for the lambda
+        //  introducer replace it with the capture name
+        auto captured_part = std::string{};
+        if (
+            n.cap_grp
+            && !for_lambda_capture
+            )
+        {
+            //  First stringize ourselves so that we compare equal against
+            //  the first *cap_grp .str_suppressed_move that matches us (which is what the
+            //  lambda introducer generator used to create a lambda capture)
+            suppress_move_from_last_use = true;
+            auto my_sym = print_to_string(n, true);
+            suppress_move_from_last_use = false;
+
+            auto found = std::find_if(n.cap_grp->members.cbegin(), n.cap_grp->members.cend(), [my_sym](auto& cap) {
+                return cap.str_suppressed_move == my_sym;
+            });
+
+            assert(
+                found != n.cap_grp->members.cend()
+                && "ICE: could not find this postfix-expression in capture group"
+            );
+            //  And then emit that capture symbol with number
+            assert (!found->cap_sym.empty());
+            captured_part += found->cap_sym;
+        }
+
+        //  Otherwise, we're going to have to potentially do some work to change
+        //  some Cpp2 postfix operators to Cpp1 prefix operators, so let's set up...
+        auto prefix            = std::vector<text_with_pos>{};
+        auto suffix            = std::vector<text_with_pos>{};
+
+        auto last_was_prefixed = false;
+        auto saw_dollar        = false;
+
+        struct text_chunks_with_parens_position {
+            std::vector<text_with_pos> text_chunks;
+            source_position            open_pos;
+            source_position            close_pos;
+        };
+
+        auto args = std::optional<text_chunks_with_parens_position>{};
+
+        auto flush_args = [&] {
+            if (args) {
+                suffix.emplace_back(")", args.value().close_pos);
+                for (auto&& e: args.value().text_chunks) {
+                    suffix.push_back(e);
+                }
+                suffix.emplace_back("(", args.value().open_pos);
+                args.reset();
+            }
+        };
+
+        auto print_to_text_chunks = [&](auto& i, auto... more) {
+            auto text = std::vector<text_with_pos>{};
+            printer.emit_to_text_chunks(&text);
+            push_need_expression_list_parens(false);
+            emit(i, more...);
+            pop_need_expression_list_parens();
+            printer.emit_to_text_chunks();
+            return text;
+        };
+
+        for (auto i = n.ops.rbegin(); i != n.ops.rend(); ++i)
+        {
+            assert(i->op);
+
+            //  If we already captured a part as a _## lambda capture,
+            //  skip the part of this expression before the $ symbol
+            //
+            if (!captured_part.empty()) {
+                if (i->op->type() == lexeme::Dollar) {
+                    break;
+                }
+            }
+            //  Else skip the part of this expression after the $ symbol
+            else if (for_lambda_capture) {
+                if (i->op->type() == lexeme::Dollar) {
+                    saw_dollar = true;
+                    continue;
+                }
+                if (!saw_dollar) {
+                    continue;
+                }
+            }
+
+            //  Going backwards if we found LeftParen it might be UFCS
+            //  expr_list is emitted to 'args' for future use
+            if (i->op->type() == lexeme::LeftParen) {
+
+                assert(i->op);
+                assert(i->op_close);
+                auto local_args = text_chunks_with_parens_position{{}, i->op->position(), i->op_close->position()};
+
+                assert (i->expr_list);
+                if (!i->expr_list->expressions.empty()) {
+                    local_args.text_chunks = print_to_text_chunks(*i->expr_list);
+                }
+
+                flush_args();
+                args.emplace(std::move(local_args));
+            }
+            //  Going backwards if we found Dot and there is args variable
+            //  it means that it should be handled by UFCS
+            else if(
+                i->op->type() == lexeme::Dot
+                && args
+                //  Disable UFCS if name lookup would hard-error (#550).
+                //  That happens when it finds that the function identifier being called is the name
+                //  of a variable with deduced type and we are in its initializer (e.g., x := y.x();)
+                //  So lower it to a member call instead, the only possible valid meaning.
+                && !lookup_finds_variable_with_placeholder_type_under_initialization(*i->id_expr)
+                )
+            {
+                //  The function name is the argument to the macro
+                auto funcname = print_to_string(*i->id_expr);
+
+                //  First, build the UFCS macro name
+
+                auto ufcs_string = std::string("CPP2_UFCS");
+
+                //  If there are template arguments, use the _TEMPLATE version
+                if (std::ssize(i->id_expr->template_arguments()) > 0) {
+                    //  If it is qualified, use the _QUALIFIED version
+                    if (i->id_expr->is_qualified()) {
+                        ufcs_string += "_QUALIFIED";
+                        //  And split the unqualified id in the function name as two macro arguments
+                        auto& id = *get<id_expression_node::qualified>(i->id_expr->id);
+                        funcname =
+                            "("
+                            + print_to_string(id, false)
+                            + "::),"
+                            + print_to_string(*cpp2::assert_not_null(id.ids.back().id), false, true, true);
+                    }
+                    ufcs_string += "_TEMPLATE";
+                }
+
+                //  If we're in an object declaration (i.e., initializer)
+                //  at namespace scope, use the _NONLOCAL version
+                //
+                //  Note: If there are other cases where code could execute
+                //  in a non-local scope where a capture-default for the UFCS
+                //  lambda would not be allowed, then add them here
+                if (
+                    current_declarations.back()->is_namespace()
+                    || (
+                        current_declarations.back()->is_object()
+                        && current_declarations.back()->parent_is_namespace()
+                        )
+                    || (
+                        (
+                         current_declarations.back()->is_alias()
+                         || (
+                             current_declarations.back()->is_function()
+                             && current_declarations.back() == having_signature_emitted
+                             )
+                         )
+                        && (
+                            current_declarations.back()->parent_is_namespace()
+                            || current_declarations.back()->parent_is_type()
+                            )
+                        )
+                    )
+                {
+                    ufcs_string += "_NONLOCAL";
+                }
+
+                //  Second, emit the UFCS argument list
+
+                prefix.emplace_back(ufcs_string + "(" + funcname + ")(", args.value().open_pos );
+                suffix.emplace_back(")", args.value().close_pos );
+                if (!args.value().text_chunks.empty()) {
+                    for (auto&& e: args.value().text_chunks) {
+                        suffix.push_back(e);
+                    }
+                    suffix.emplace_back(", ", i->op->position());
+                }
+                args.reset();
+            }
+
+            //  Handle the Cpp2 postfix operators that are prefix in Cpp1
+            //
+            else if (
+                i->op->type() == lexeme::MinusMinus
+                || i->op->type() == lexeme::PlusPlus
+                || i->op->type() == lexeme::Multiply
+                || i->op->type() == lexeme::Ampersand
+                || i->op->type() == lexeme::Tilde
+                )
+            {
+                // omit some needless parens
+                if (
+                    !last_was_prefixed
+                    && i != n.ops.rbegin()
+                    )
+                {
+                    prefix.emplace_back( "(", i->op->position() );
+                }
+                prefix.emplace_back( i->op->to_string(), i->op->position());
+
+                //  Enable null dereference checks
+                if (
+                    flag_safe_null_pointers
+                    && i->op->type() == lexeme::Multiply
+                    )
+                {
+                    prefix.emplace_back( "cpp2::assert_not_null(", i->op->position() );
+                }
+                if (
+                    flag_safe_null_pointers
+                    && i->op->type() == lexeme::Multiply
+                    )
+                {
+                    suffix.emplace_back( ")", i->op->position() );
+                }
+
+                // omit some needless parens
+                if (
+                    !last_was_prefixed
+                    && i != n.ops.rbegin()
+                    )
+                {
+                    suffix.emplace_back( ")", i->op->position() );
+                }
+                last_was_prefixed = true;
+            }
+
+            //  Handle the other Cpp2 postfix operators that stay postfix in Cpp1 (currently: '...')
+            else if (is_postfix_operator(i->op->type())) {
+                flush_args();
+                suffix.emplace_back( i->op->to_string(), i->op->position());
+            }
+
+            //  Handle the suffix operators that remain suffix
+            //
+            else {
+                assert(i->op);
+                last_was_prefixed = false;
+
+                //  Enable subscript bounds checks
+                if (
+                    flag_safe_subscripts
+                    && i->op->type() == lexeme::LeftBracket
+                    && std::ssize(i->expr_list->expressions) == 1
+                    )
+                {
+                    suffix.emplace_back( ")", i->op->position() );
+                }
+                else if (i->op_close) {
+                    suffix.emplace_back( i->op_close->to_string(), i->op_close->position() );
+                }
+
+                if (i->id_expr)
+                {
+                    if (args) {
+                        //  If args are stored it means that this is function or method
+                        //  that is not handled by UFCS and args need to be printed
+                        suffix.emplace_back(")", args.value().close_pos);
+                        for (auto&& e: args.value().text_chunks) {
+                            suffix.push_back(e);
+                        }
+                        suffix.emplace_back("(", args.value().open_pos);
+                        args.reset();
+                    }
+
+                    auto print = print_to_string(*i->id_expr, false /*not a local name*/);
+                    suffix.emplace_back( print, i->id_expr->position() );
+                }
+
+                if (i->expr_list) {
+                    auto text = print_to_text_chunks(*i->expr_list);
+                    for (auto&& e: text) {
+                        suffix.push_back(e);
+                    }
+                }
+
+                //  Enable subscript bounds checks
+                if (
+                    flag_safe_subscripts
+                    && i->op->type() == lexeme::LeftBracket
+                    && std::ssize(i->expr_list->expressions) == 1
+                    )
+                {
+                    prefix.emplace_back( "CPP2_ASSERT_IN_BOUNDS(", i->op->position() );
+                    suffix.emplace_back( ", ", i->op->position() );
+                }
+                else {
+                    suffix.emplace_back( i->op->to_string(), i->op->position() );
+                }
+            }
+        }
+
+        //  Print the prefixes (in forward order)
+        for (auto& e : prefix) {
+            printer.print_cpp2(e.text, n.position());
+        }
+
+        //  If this is an --, ++, or &, don't add std::move on the lhs
+        //  even if this is a definite last use (only do that when an rvalue is okay)
+        if (
+            n.ops.front().op->type() == lexeme::MinusMinus
+            || n.ops.front().op->type() == lexeme::PlusPlus
+            || n.ops.front().op->type() == lexeme::Ampersand
+            )
+        {
+            suppress_move_from_last_use = true;
+        }
+
+        //  Now print the core expression -- or the captured_part in its place
+        if (captured_part.empty()) {
+            emit(*n.expr);
+        }
+        else {
+            printer.print_cpp2(captured_part, n.position());
+        }
+        suppress_move_from_last_use = false;
+
+        flush_args();
+
+        //  Print the suffixes (in reverse order)
+        while (!suffix.empty()) {
+            printer.print_cpp2(suffix.back().text, suffix.back().pos);
+            suffix.pop_back();
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(prefix_expression_node const& n)
+        -> void
+    {   STACKINSTR
+        auto suffix = std::string{};
+        for (auto const& x : n.ops) {
+            assert(x);
+            if (x->type() == lexeme::Not) {
+                printer.print_cpp2("!(", n.position());
+                printer.add_pad_in_this_line(-3);
+                suffix += ")";
+            }
+            else {
+                printer.print_cpp2(*x, x->position());
+            }
+        }
+        assert(n.expr);
+        push_need_expression_list_parens(true);
+        emit(*n.expr);
+        pop_need_expression_list_parens();
+        printer.print_cpp2(suffix, n.position());
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(is_as_expression_node const& n)
+        -> void
+    {   STACKINSTR
+        std::string prefix = {};
+        std::string suffix = {};
+
+        auto wildcard_found = false;
+        bool as_on_literal  = false;
+
+        assert(
+            n.expr
+            && n.expr->get_postfix_expression_node()
+            && n.expr->get_postfix_expression_node()->expr
+        );
+        {
+            auto& p = n.expr->get_postfix_expression_node()->expr;
+            if (auto t = p->get_token();
+                t
+                && is_literal(t->type())
+                && t->type() != lexeme::StringLiteral
+                && t->type() != lexeme::FloatLiteral
+                && !std::get<primary_expression_node::literal>(p->expr)->user_defined_suffix
+                && std::ssize(n.ops) > 0
+                && *n.ops[0].op == "as"
+                )
+            {
+                as_on_literal = true;
+            }
+        }
+
+        for (
+            auto i = n.ops.rbegin();
+            i != n.ops.rend();
+            ++i
+            )
+        {
+            //  If it's "ISORAS type", emit "cpp2::ISORAS<type>(expr)"
+            if (i->type)
+            {
+                if (i->type->is_wildcard()) {
+                    wildcard_found = true;
+                    if (*i->op != "is") {
+                        errors.emplace_back(
+                            n.position(),
+                            "'as _' wildcard is not allowed, specify a concrete target type instead"
+                        );
+                    }
+                    else if (std::ssize(n.ops) > 1) {
+                        errors.emplace_back(
+                            n.position(),
+                            "an 'is _' wildcard may only be used on its own, not in a chain with other 'is'/'as' in the same subexpression"
+                        );
+                    }
+                }
+                else {
+                    auto op_name = i->op->to_string();
+                    if (op_name == "as") {
+                        op_name = "as_";    // use the static_assert-checked 'as' by default...
+                    }                       // we'll override this inside inspect-expressions
+                    prefix += "cpp2::" + op_name + "<" + print_to_string(*i->type) + ">(";
+                    suffix = ")" + suffix;
+                }
+            }
+            //  Else it's "is value", emit "cpp2::is(expr, value)"
+            else
+            {
+                assert(i->expr);
+                prefix += "cpp2::" + i->op->to_string() + "(";
+                suffix = ", " + print_to_string(*i->expr) + ")" + suffix;
+            }
+        }
+
+        if (as_on_literal) {
+            auto last_pos = prefix.rfind('>'); assert(last_pos != prefix.npos);
+            prefix.insert(last_pos, ", " + print_to_string(*n.expr));
+        }
+
+        printer.print_cpp2(prefix, n.position());
+        if (wildcard_found) {
+            printer.print_cpp2("true", n.position());
+        }
+        else if(!as_on_literal) {
+            emit(*n.expr);
+        }
+        printer.print_cpp2(suffix, n.position());
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    template<
+        String   Name,
+        typename Term
+    >
+    auto emit(binary_expression_node<Name,Term> const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.expr);
+        assert(
+            n.terms.empty()
+            || n.terms.front().op
+        );
+
+        //  If this is relational comparison
+        if (
+            !n.terms.empty()
+            && (
+                n.terms.front().op->type() == lexeme::Less
+                || n.terms.front().op->type() == lexeme::LessEq
+                || n.terms.front().op->type() == lexeme::Greater
+                || n.terms.front().op->type() == lexeme::GreaterEq
+                || n.terms.front().op->type() == lexeme::EqualComparison
+                || n.terms.front().op->type() == lexeme::NotEqualComparison
+                )
+            )
+        {
+            auto const& op = *n.terms.front().op;
+
+            //  If this is one (non-chained) comparison, just emit it directly
+            if (std::ssize(n.terms) < 2)
+            {
+                assert (std::ssize(n.terms) == 1);
+
+                //  emit < <= >= > as cmp_*(a,b) calls (if selected)
+                if (flag_safe_comparisons) {
+                    switch (op.type()) {
+                    break;case lexeme::Less:
+                        printer.print_cpp2( "cpp2::cmp_less(", n.position());
+                    break;case lexeme::LessEq:
+                        printer.print_cpp2( "cpp2::cmp_less_eq(", n.position());
+                    break;case lexeme::Greater:
+                        printer.print_cpp2( "cpp2::cmp_greater(", n.position());
+                    break;case lexeme::GreaterEq:
+                        printer.print_cpp2( "cpp2::cmp_greater_eq(", n.position());
+                    break;default:
+                        ;
+                    }
+                }
+
+                emit(*n.expr);
+
+                //  emit == and != as infix a ? b operators (since we don't have
+                //  any checking/instrumentation we want to do for those)
+                if (flag_safe_comparisons) {
+                    switch (op.type()) {
+                    break;case lexeme::EqualComparison:
+                          case lexeme::NotEqualComparison:
+                        printer.print_cpp2( " ", n.position() );
+                        emit(op);
+                        printer.print_cpp2( " ", n.position() );
+                    break;default:
+                        printer.print_cpp2( ",", n.position() );
+                    }
+                }
+                else {
+                    emit(op);
+                }
+
+                emit(*n.terms.front().expr);
+
+                if (flag_safe_comparisons) {
+                    switch (op.type()) {
+                    break;case lexeme::Less:
+                          case lexeme::LessEq:
+                          case lexeme::Greater:
+                          case lexeme::GreaterEq:
+                        printer.print_cpp2( ")", n.position() );
+                    break;default:
+                        ;
+                    }
+                }
+
+                return;
+            }
+
+            //  Else if this is a chained comparison, emit it as a lambda,
+            //  to get single evaluation via the lambda capture
+            else
+            {
+                //  To check for the valid chains: all </<=, all >/>=, or all ==
+                auto found_lt = 0;  // < and <=
+                auto found_gt = 0;  // > and >=
+                auto found_eq = 0;  // ==
+                auto count    = 0;
+
+                auto const* lhs = n.expr.get();
+                auto lhs_name = "_" + std::to_string(count);
+
+                auto lambda_capture = lhs_name + " = " + print_to_string(*lhs);
+                auto lambda_body    = std::string{};
+
+                for (auto const& term : n.terms)
+                {
+                    assert(
+                        term.op
+                        && term.expr
+                    );
+                    ++count;
+                    auto rhs_name = "_" + std::to_string(count);
+
+                    //  Not the first expression? Insert a "&&"
+                    if (found_lt + found_gt + found_eq > 0) {
+                        lambda_body += " && ";
+                    }
+
+                    //  Remember what we've seen
+                    switch (term.op->type()) {
+                    break;case lexeme::Less:
+                          case lexeme::LessEq:
+                        found_lt = 1;
+                    break;case lexeme::Greater:
+                          case lexeme::GreaterEq:
+                        found_gt = 1;
+                    break;case lexeme::EqualComparison:
+                        found_eq = 1;
+                    break;default:
+                        ;
+                    }
+
+                    //  emit < <= >= > as cmp_*(a,b) calls (if selected)
+                    if (flag_safe_comparisons) {
+                        switch (term.op->type()) {
+                        break;case lexeme::Less:
+                            lambda_body += "cpp2::cmp_less(";
+                        break;case lexeme::LessEq:
+                            lambda_body += "cpp2::cmp_less_eq(";
+                        break;case lexeme::Greater:
+                            lambda_body += "cpp2::cmp_greater(";
+                        break;case lexeme::GreaterEq:
+                            lambda_body += "cpp2::cmp_greater_eq(";
+                        break;default:
+                            ;
+                        }
+                    }
+
+                    auto rhs_expr = print_to_string(*term.expr);
+
+                    lambda_body += lhs_name;
+
+                    //  emit == and != as infix a ? b operators (since we don't have
+                    //  any checking/instrumentation we want to do for those)
+                    if (flag_safe_comparisons) {
+                        switch (term.op->type()) {
+                        break;case lexeme::EqualComparison:
+                            lambda_body += *term.op;
+                        break;case lexeme::NotEqualComparison:
+                            errors.emplace_back(
+                                n.position(),
+                                "!= comparisons cannot appear in a comparison chain (see https://wg21.link/p0893)"
+                            );
+                            return;
+                        break;default:
+                            lambda_body += ",";
+                        }
+                    }
+                    else {
+                        lambda_body += *term.op;
+                    }
+
+                    lambda_capture += ", " + rhs_name + " = " + rhs_expr;
+                    lambda_body    += rhs_name;
+
+                    lhs = term.expr.get();
+                    lhs_name = rhs_name;
+
+                    if (flag_safe_comparisons) {
+                        switch (term.op->type()) {
+                        break;case lexeme::Less:
+                                case lexeme::LessEq:
+                                case lexeme::Greater:
+                                case lexeme::GreaterEq:
+                            lambda_body += ")";
+                        break;default:
+                            ;
+                        }
+                    }
+                }
+
+                assert(found_lt + found_gt + found_eq > 0);
+                if (found_lt + found_gt + found_eq != 1) {
+                    errors.emplace_back(
+                        n.position(),
+                        "a comparison chain must be all < and <=, all > and >=, or all == (see https://wg21.link/p0893)"
+                    );
+                    return;
+                }
+
+                printer.print_cpp2( "[" + lambda_capture + "]{ return " + lambda_body + "; }()", n.position());
+
+                return;
+            }
+        }
+
+        //  Else if this is an assignment expression, don't add std::move on the lhs
+        //  even if this is a definite last use (only do that when an rvalue is okay)
+        if (
+            !n.terms.empty()
+            && is_assignment_operator(n.terms.front().op->type())
+            )
+        {
+            suppress_move_from_last_use = true;
+        }
+        //  If it's "_ =" then emit static_cast<void>()
+        bool emit_discard = false;
+        if (
+            !n.terms.empty()
+            && n.terms.front().op->type() == lexeme::Assignment
+            && n.expr->get_postfix_expression_node()
+            && n.expr->get_postfix_expression_node()->get_first_token_ignoring_this()
+            && *n.expr->get_postfix_expression_node()->get_first_token_ignoring_this() == "_"
+            )
+        {
+            printer.print_cpp2( "static_cast<void>(", n.position() );
+            emit_discard = true;
+        }
+        else
+        {
+            emit(*n.expr);
+        }
+        suppress_move_from_last_use = false;
+
+        //  Check that this isn't an illegal pointer operation
+        //      (initial partial implementation)
+        if (
+            !n.terms.empty()
+            && last_postfix_expr_was_pointer
+            )
+        {
+            auto rhs_post = n.get_second_postfix_expression_node();
+            assert(
+                rhs_post
+                && rhs_post->expr
+            );
+            auto rhs_tok = rhs_post->expr->get_token();
+            if (
+                is_assignment_operator(n.terms.front().op->type())
+                && rhs_tok
+                && (
+                    *rhs_tok == "nullptr"
+                    || is_digit((rhs_tok->as_string_view())[0])
+                    )
+                )
+            {
+                errors.emplace_back(
+                    n.terms.front().op->position(),
+                    n.terms.front().op->to_string() + " - pointer assignment from null or integer is illegal"
+                );
+                violates_lifetime_safety = true;
+            }
+            else if (
+                *n.terms.front().op == "+"
+                || *n.terms.front().op == "+="
+                || *n.terms.front().op == "-"
+                || *n.terms.front().op == "-="
+                )
+            {
+                errors.emplace_back(
+                    n.terms.front().op->position(),
+                    n.terms.front().op->to_string() + " - pointer arithmetic is illegal - use std::span or gsl::span instead"
+                );
+                violates_bounds_safety = true;
+            }
+        }
+
+        auto first = true;
+        for (auto const& x : n.terms) {
+            assert(x.op);
+            assert(x.expr);
+
+            //  Normally we'll just emit the operator, but if this is an
+            //  assignment that's a definite initialization, change it to
+            //  a .construct() call
+            if (
+                x.op->type() == lexeme::Assignment
+                && in_definite_init
+                )
+            {
+                printer.print_cpp2( ".construct(", n.position() );
+                emit(*x.expr);
+                printer.print_cpp2( ")", n.position() );
+            }
+            else
+            {
+                //  For the first operator only, if we are emitting a "_ =" discard
+                //  then we don't need the =
+                if (
+                    !emit_discard
+                    || !first
+                ) {
+                    printer.print_cpp2(" ", n.position());
+                    emit(*x.op);
+                    printer.print_cpp2(" ", n.position());
+                }
+
+                //  When assigning a single expression-list, we can
+                //  take over direct control of emitting it without needing to
+                //  go through the whole grammar, and surround it with braces
+                if (
+                    x.op->type() == lexeme::Assignment
+                    && x.expr->is_expression_list()
+                    )
+                {
+                    printer.print_cpp2( "{ ", n.position() );
+                    emit(*x.expr->get_expression_list(), false);
+                    printer.print_cpp2( " }", n.position() );
+                }
+                //  Otherwise, just emit the general expression as usual
+                else {
+                    emit(*x.expr);
+                }
+            }
+
+            first = false;
+        }
+        // Finish emitting the "_ =" discard.
+        if (emit_discard) {
+            printer.print_cpp2( ")", n.position() );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(expression_node const& n)
+        -> void
+    {   STACKINSTR
+        assert(n.expr);
+        push_need_expression_list_parens(true);
+        emit(*n.expr);
+        pop_need_expression_list_parens();
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        expression_list_node const& n,
+        bool                        parens_ok = true
+    )
+        -> void
+    {   STACKINSTR
+        auto add_parens =
+            should_add_expression_list_parens()
+            && !n.inside_initializer
+            && parens_ok
+            ;
+        add_parens |=
+            n.is_fold_expression() &&
+            !(n.inside_initializer && current_declarations.back()->initializer->position() != n.open_paren->position())
+            ;
+        if (add_parens) {
+            printer.print_cpp2( *n.open_paren, n.position());
+        }
+
+        auto first = true;
+        for (auto const& x : n.expressions) {
+            if (!first) {
+                printer.print_cpp2(", ", n.position());
+            }
+            first = false;
+            auto is_out = false;
+
+            if (x.pass != passing_style::in) {
+                assert(
+                    x.pass == passing_style::out
+                    || x.pass == passing_style::move
+                    || x.pass == passing_style::forward
+                );
+                if (x.pass == passing_style::out) {
+                    is_out = true;
+                    printer.print_cpp2("cpp2::out(&", n.position());
+                }
+                else if (x.pass == passing_style::move) {
+                    printer.print_cpp2("std::move(", n.position());
+                }
+            }
+
+            if (is_out) {
+                in_non_rvalue_context.push_back(true);
+            }
+
+            assert(x.expr);
+            current_args.push_back( {x.pass} );
+            emit(*x.expr);
+            current_args.pop_back();
+
+            if (is_out) {
+                in_non_rvalue_context.pop_back();
+            }
+
+            if (
+                x.pass == passing_style::move
+                || x.pass == passing_style::out
+                )
+            {
+                printer.print_cpp2(")", n.position());
+            }
+        }
+
+        if (add_parens) {
+            printer.print_cpp2( *n.close_paren, n.position());
+        }
+        //  We want to consume only one of these
+        consumed_expression_list_parens();
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        expression_statement_node const& n,
+        bool                             can_have_semicolon,
+        source_position                  function_body_start = {},
+        bool                             function_void_ret   = false,
+        function_prolog const&           function_prolog     = {},
+        std::vector<std::string> const&  function_epilog     = {},
+        bool                             emitted             = false
+    )
+        -> void
+    {   STACKINSTR
+        assert(n.expr);
+        auto generating_return = false;
+
+        if (function_body_start != source_position{}) {
+            emit_prolog_mem_inits(function_prolog, n.position().colno);
+            printer.print_cpp2(" { ", function_body_start);
+            emit_prolog_statements(function_prolog, n.position().colno);
+            if (!function_void_ret) {
+                printer.print_cpp2("return ", n.position());
+                generating_return = true;
+            }
+        }
+
+        if (!emitted) {
+            //  When generating 'return' of a single expression-list, we can
+            //  take over direct control of emitting it without needing to
+            //  go through the whole grammar, and surround it with braces
+            if (
+                generating_return
+                && n.expr->is_expression_list()
+                && !n.expr->get_expression_list()->is_fold_expression()
+                )
+            {
+                auto is_deduced_return =
+                    !function_returns.empty()
+                    && function_returns.back().is_deduced;
+
+                if (!is_deduced_return) {
+                    printer.print_cpp2( "{ ", n.position() );
+                }
+                emit(*n.expr->get_expression_list(), false);
+                if (!is_deduced_return) {
+                    printer.print_cpp2( " }", n.position() );
+                }
+            }
+            //  Otherwise, just emit the general expression as usual
+            else {
+                emit(*n.expr);
+            }
+            if (can_have_semicolon) {
+                printer.print_cpp2(";", n.position());
+            }
+        }
+
+        if (function_body_start != source_position{}) {
+            emit_epilog_statements( function_epilog, n.position().colno);
+            printer.print_cpp2(" }", n.position());
+        }
+    }
+
+
+    // Consider moving these `stack` functions to `common.h` to enable more general use.
+
+    template<typename T>
+    auto stack_value(
+        T& var,
+        std::type_identity_t<T> const& value
+    )
+        -> auto
+    {
+        return finally([&var, old = std::exchange(var, value)]() {
+            var = old;
+        });
+    }
+
+    template<typename T>
+    auto stack_element(
+        std::vector<T>& cont,
+        std::type_identity_t<T> const& value
+    )
+        -> auto
+    {
+        cont.push_back(value);
+        return finally([&]{ cont.pop_back(); });
+    }
+
+    template<typename T>
+    auto stack_size(std::vector<T>& cont)
+        -> auto
+    {
+        return finally([&, size = cont.size()]{ cont.resize(size); });
+    }
+
+    template<typename T>
+    auto stack_size_if(
+        std::vector<T>& cont,
+        bool cond
+    )
+        -> std::optional<decltype(stack_size(cont))>
+    {
+        if (cond) {
+            return stack_size(cont);
+        }
+        return {};
+    }
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        statement_node const&           n,
+        bool                            can_have_semicolon  = true,
+        source_position                 function_body_start = {},
+        bool                            function_void_ret   = false,
+        function_prolog const&          function_prolog     = {},
+        std::vector<std::string> const& function_epilog     = {}
+    )
+        -> void
+    {   STACKINSTR
+        if (!sema.check(n)) {
+            return;
+        }
+
+        auto emit_parameters =
+            !n.emitted
+            && n.parameters
+            ;
+
+        auto guard = stack_size_if(current_names, emit_parameters);
+        if (emit_parameters) {
+            printer.print_extra( "\n");
+            printer.print_extra( "{");
+            for (auto& param : n.parameters->parameters) {
+                printer.print_extra( "\n");
+                printer.print_extra( print_to_string(*param) );
+            }
+        }
+
+        //  Do expression statement case first... it's the most complex
+        //  because it's used for single-statement function bodies
+        try_emit<statement_node::expression >(
+            n.statement,
+            can_have_semicolon,
+            function_body_start,
+            function_void_ret,
+            function_prolog,
+            function_epilog,
+            n.emitted
+        );
+
+        //  Otherwise, skip this one if it was already handled earlier (i.e., a constructor member init)
+        if (n.emitted) {
+            return;
+        }
+
+        printer.disable_indent_heuristic_for_next_text();
+
+        try_emit<statement_node::compound   >(n.statement, function_prolog, function_epilog);
+
+        //  NOTE: Reset preemption here because
+        //  - for compound statements written as "= { ... }", we want to keep the
+        //    preempted position which moves the { to where the = was
+        //  - but for other statement types, we want to get rid of any leftover
+        //    preemption (ideally there wouldn't be any, but sometimes there is
+        //    and it should not apply to what we're about to emit)
+        printer.preempt_position_push({});
+        //  This only has a whitespace effect in the generated Cpp1 code, but it's
+        //  aesthetic and aesthetics are important in this case -- we want to keep
+        //  the original source's personal whitespace formatting style as much as we can
+
+        try_emit<statement_node::selection  >(n.statement);
+        try_emit<statement_node::declaration>(n.statement);
+        try_emit<statement_node::return_    >(n.statement);
+        try_emit<statement_node::iteration  >(n.statement);
+        try_emit<statement_node::using_     >(n.statement);
+        try_emit<statement_node::contract   >(n.statement);
+        try_emit<statement_node::inspect    >(n.statement, false);
+        try_emit<statement_node::jump       >(n.statement);
+
+        printer.preempt_position_pop();
+
+        if (emit_parameters) {
+            printer.print_extra( "\n");
+            printer.print_extra( "}");
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Within a type scope implementation, disallow declaring a name that
+    //  is the same as (i.e., shadows) a type scope name... this is a
+    //  convenient place to check because we have the decls stack
+    //
+    auto check_shadowing_of_type_scope_names(
+        declaration_node const& decl
+    )
+        -> bool
+    {
+        if (
+            decl.has_name()                 // this is a named declaration
+            && !decl.has_name("this")       // that's not 'this'
+            && !decl.parent_is_type()       // and the type isn't the direct parent
+            && is_name_declared_in_current_type_scope(*decl.name())
+            )                               // and it shadows a name
+        {
+            errors.emplace_back(
+                decl.position(),
+                "a type's implementation may not declare a name that is the same as (i.e., shadows) a type scope name - for example, a type scope function's local variable may not have the same as one of the type's members"
+            );
+            return false;
+        }
+
+        return true;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        parameter_declaration_node const& n,
+        bool                              is_returns            = false,
+        bool                              is_template_parameter = false
+    )
+        -> void
+    {   STACKINSTR
+        if (!sema.check(n)) {
+            return;
+        }
+
+        //  Can't declare functions as parameters -- only pointers to functions which are objects
+        assert( n.declaration );
+        assert( !n.declaration->is_function() );
+
+        if (!check_shadowing_of_type_scope_names(*n.declaration)) {
+            return;
+        }
+
+        assert( n.declaration->identifier );
+        auto identifier     = print_to_string( *n.declaration->identifier );
+        auto identifier_pos = n.position();
+
+        if (n.mod == parameter_declaration_node::modifier::implicit)
+        {
+            assert(!current_functions.empty());
+            if (
+                n.pass != passing_style::out
+                || !current_functions.back().decl->has_name("operator=")
+                )
+            {
+                errors.emplace_back(
+                    n.position(),
+                    "only an 'out this' parameter of an 'operator=' function may be declared implicit"
+                );
+            }
+        }
+
+        current_names.push_back(&*n.declaration);
+
+        //-----------------------------------------------------------------------
+        //  Skip 'this' parameters
+
+        if (n.declaration->has_name("this"))
+        {
+            //  Since we're skipping "out this," plus possibly "implicit " and
+            //  whitespace, any following parameters on the same line can shift left
+            printer.add_pad_in_this_line(-18);
+
+            return;
+        }
+
+        //-----------------------------------------------------------------------
+        //  Handle 'that' parameters
+
+        if (n.declaration->has_name("that"))
+        {
+            emitting_that_function = true;
+            assert(
+                n.pass == passing_style::in
+                || n.pass == passing_style::move
+            );
+            auto pass = std::string{" const&"};
+            if (
+                n.pass == passing_style::move
+                || emitting_move_that_function
+                )
+            {
+                pass = "&&";
+            }
+
+            auto func_name = get_enclosing_function_name();
+            assert(func_name);
+
+            auto type_name = get_enclosing_type_name();
+            assert(type_name);
+
+            //  If we're in an empty type that has no member object, mark 'that' as
+            //  [[maybe_unused]] to silence Cpp1 compiler warnings
+            assert(!current_functions.empty());
+            auto maybe_unused = std::string{};
+            if (current_functions.back().decl->get_parent()->get_type_scope_declarations(declaration_node::objects).empty()) {
+                maybe_unused = "[[maybe_unused]] ";
+            }
+
+            printer.print_cpp2(
+                maybe_unused + print_to_string( *type_name ) + pass + " that",
+                n.position()
+            );
+            return;
+        }
+
+        //-----------------------------------------------------------------------
+        //  Handle type parameters
+
+        if (n.declaration->is_type()) {
+            assert( is_template_parameter );
+            printer.print_cpp2("typename ", identifier_pos);
+            if (n.declaration->is_variadic) {
+                printer.print_cpp2(
+                    "...",
+                    identifier_pos
+                );
+            }
+
+            if (identifier == "_") {
+                printer.print_cpp2( "UnnamedTypeParam" + std::to_string(n.ordinal), identifier_pos );
+            }
+            else {
+                printer.print_cpp2( identifier, identifier_pos );
+            }
+
+            return;
+        }
+
+        //-----------------------------------------------------------------------
+        //  Else handle template non-type parameters
+
+        assert( n.declaration->is_object() );
+        auto const& type_id = *std::get<declaration_node::an_object>(n.declaration->type);
+
+        if (is_template_parameter) {
+            emit( type_id );
+            printer.print_cpp2(" ", type_id.position());
+                printer.print_cpp2( identifier, identifier_pos );
+            return;
+        }
+
+        //-----------------------------------------------------------------------
+        //  Else handle ordinary parameters
+
+        auto param_type = print_to_string(type_id);
+
+        //  If there are template parameters on this function or its enclosing
+        //  type, see if this parameter's name is an unqualified-id with a
+        //  template parameter name, or mentions a template parameter as a
+        //  template argument
+        auto has_template_parameter_type_named = [](
+            declaration_node const& decl,
+            std::string_view        name
+            )
+            -> bool
+        {
+            if (decl.template_parameters) {
+                for (auto& tparam : decl.template_parameters->parameters)
+                {
+                    assert(
+                        tparam
+                        && tparam->name()
+                    );
+                    //  For now just do a quick string match
+                    auto tparam_name = tparam->name()->to_string();
+                    if (
+                        tparam->declaration->is_type()
+                        && (
+                            name == tparam_name
+                            || name.find("<"+tparam_name) != std::string_view::npos
+                            || name.find(","+tparam_name) != std::string_view::npos
+                        )
+                        )
+                    {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+
+        assert( current_declarations.back() );
+        auto is_dependent_parameter_type =
+            has_template_parameter_type_named( *current_declarations.back(), param_type )
+            || (
+                current_declarations.back()->parent_is_type()
+                && current_declarations.back()->has_name("operator=")
+                && has_template_parameter_type_named( *current_declarations.back()->get_parent(), param_type)
+                )
+            ;
+
+        //  First any prefix
+
+        if (identifier == "_") {
+            printer.print_cpp2( "[[maybe_unused]] ", identifier_pos );
+            identifier = "unnamed_param_" + std::to_string(n.ordinal);
+        }
+
+        if (
+            !is_returns
+            && !n.declaration->is_variadic
+            && !type_id.is_wildcard()
+            && !is_dependent_parameter_type
+            && !type_id.is_pointer_qualified()
+            )
+        {
+            switch (n.pass) {
+            break;case passing_style::in     : printer.print_cpp2( "cpp2::in<",  n.position() );
+            break;case passing_style::out    : printer.print_cpp2( "cpp2::out<", n.position() );
+            break;default: ;
+            }
+        }
+
+        printer.preempt_position_push( n.position() );
+
+        if (
+            type_id.is_pointer_qualified()
+            && n.pass == passing_style::in
+            )
+        {
+            printer.print_cpp2( param_type, n.position() );
+        }
+        else if (
+            type_id.is_wildcard()
+            || is_dependent_parameter_type
+            || n.declaration->is_variadic
+            )
+        {
+            auto name = std::string{"auto"};
+            if (is_dependent_parameter_type) {
+                name = param_type;
+            }
+            else if (
+                n.declaration->is_variadic
+                && !type_id.is_wildcard()
+                )
+            {
+                auto name = n.declaration->identifier->get_token();
+                assert(name);
+                auto req = std::string{"(std::is_convertible_v<CPP2_TYPEOF("};
+                req += *name;
+                req += "), ";
+                req += param_type;
+                req += "> && ...)";
+                function_requires_conditions.push_back(req);
+            }
+
+            switch (n.pass) {
+            break;case passing_style::in     : printer.print_cpp2( name+" const&", n.position() );
+            break;case passing_style::copy   : printer.print_cpp2( name,           n.position() );
+            break;case passing_style::inout  : printer.print_cpp2( name+"&",       n.position() );
+
+            //  For generic out parameters, we take a pointer to anything with paramater named "identifier_"
+            //  and then generate the out<> as a stack local with the expected name "identifier"
+            break;case passing_style::out    : printer.print_cpp2( name,           n.position() );
+                                               current_functions.back().prolog.statements.push_back(
+                                                   "auto " + identifier + " = cpp2::out(" + identifier + "_); "
+                                               );
+                                               identifier += "_";
+
+            break;case passing_style::move   : printer.print_cpp2( name+"&&",      n.position() );
+            break;case passing_style::forward: printer.print_cpp2( name+"&&",      n.position() );
+            break;default: ;
+            }
+        }
+        else if (n.pass == passing_style::forward) {
+            printer.print_cpp2("auto", n.position());
+
+            auto name = n.declaration->identifier->get_token();
+            assert(name);
+            auto req = std::string{"std::is_same_v<CPP2_TYPEOF("};
+            req += *name;
+            req += "), ";
+            req += param_type;
+            req += ">";
+            function_requires_conditions.push_back(req);
+        }
+        else {
+            if (is_returns) {
+                printer.print_extra( param_type );
+            }
+            else {
+                printer.print_cpp2( param_type, type_id.position() );
+            }
+        }
+
+        printer.preempt_position_pop();
+
+        //  Then any suffix
+
+        if (
+            !is_returns
+            && !type_id.is_wildcard()
+            && !is_dependent_parameter_type
+            && !type_id.is_pointer_qualified()
+            && !n.declaration->is_variadic
+            )
+        {
+            switch (n.pass) {
+            break;case passing_style::in     : printer.print_cpp2( ">",  n.position() );
+            break;case passing_style::copy   : printer.print_cpp2( "",   n.position() );
+            break;case passing_style::inout  : printer.print_cpp2( "&",  n.position() );
+            break;case passing_style::out    : printer.print_cpp2( ">",  n.position() );
+            break;case passing_style::move   : printer.print_cpp2( "&&", n.position() );
+            break;case passing_style::forward: printer.print_cpp2( "&&", n.position() );
+            break;default: ;
+            }
+        }
+
+        if (is_returns) {
+            printer.print_extra( " " + identifier );
+        }
+        else {
+            printer.print_cpp2( " ", identifier_pos );
+            if (n.declaration->is_variadic)
+            {
+                if (n.direction() == passing_style::out) {
+                    errors.emplace_back(
+                        n.declaration->position(),
+                        "a variadic parameter cannot be 'out'"
+                    );
+                    return;
+                }
+
+                printer.print_cpp2(
+                    "...",
+                    identifier_pos
+                );
+            }
+            printer.print_cpp2( identifier, identifier_pos );
+        }
+
+        if (
+            !is_returns
+            && n.declaration->initializer
+            )
+        {
+            auto guard = stack_element(current_declarations, &*n.declaration);
+            printer.print_cpp2( " = ", n.declaration->initializer->position() );
+            emit(*n.declaration->initializer);
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        parameter_declaration_list_node const& n,
+        bool                                   is_returns                 = false,
+        bool                                   is_template_parameter      = false,
+        bool                                   generating_postfix_inc_dec = false
+    )
+        -> void
+    {   STACKINSTR
+        in_parameter_list = true;
+
+        if (is_returns) {
+            printer.print_extra( "{ " );
+        }
+        else {
+            assert(n.open_paren);
+            emit(*n.open_paren);
+        }
+
+        //  So we don't get cute about text-aligning the first parameter when it's on a new line
+        printer.disable_indent_heuristic_for_next_text();
+
+        auto prev_pos = n.position();
+        auto first    = true;
+        for (auto const& x : n.parameters) {
+            if (
+                !first
+                && !is_returns
+                )
+            {
+                printer.print_cpp2( ", ", prev_pos );
+            }
+            prev_pos = x->position();
+            assert(x);
+            emit(*x, is_returns, is_template_parameter);
+            if (!x->declaration->has_name("this")) {
+                first = false;
+            }
+            if (is_returns) {
+                printer.print_extra( "; " );
+            }
+        }
+
+        if (is_returns) {
+            printer.print_extra( "};\n" );
+        }
+        else {
+            //  If we're generating Cpp1 postfix ++ or --, add the dummy int parameter
+            if (generating_postfix_inc_dec) {
+                if (!first) {
+                    printer.print_cpp2( ",", n.position() );
+                }
+                printer.print_cpp2( "int", n.position() );
+            }
+
+            //  Position heuristic (aka hack): Avoid emitting extra whitespace before )
+            //  beyond column 10
+            assert(n.close_paren);
+            auto col = std::min( n.close_paren->position().colno, colno_t{10});
+            printer.preempt_position_push({ n.close_paren->position().lineno, col});
+            emit(*n.close_paren);
+            printer.preempt_position_pop();
+        }
+
+        in_parameter_list = false;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        // note: parameter is deliberately not const because we will fill
+        //       in the capture .str information
+        contract_node& n
+    )
+        -> void
+    {   STACKINSTR
+        assert (n.kind);
+
+        //  If this is one of Cpp2's predefined contract groups,
+        //  make it convenient to use without cpp2:: qualification
+        auto name = std::string{"cpp2::Default"};
+        if (n.group)
+        {
+            auto group = print_to_string(*n.group);
+            if (group != "_") {
+                name = group;
+            }
+            if (
+                name == "Default"
+                || name == "Bounds"
+                || name == "Null"
+                || name == "Type"
+                || name == "Testing"
+                )
+            {
+                name.insert(0, "cpp2::");
+            }
+        }
+
+        //  "Unevaluated" is for static analysis only, and are never evaluated, so just skip them
+        //  (The only requirement for an Unevaluated condition is that it parses; and even that's
+        //  easy to relax if we ever want to allow arbitrary tokens in an Unevaluated condition)
+        if (n.group && n.group->to_string() == "Unevaluated") {
+            return;
+        }
+
+        //  For a postcondition, we'll wrap it in a lambda and register it
+        //
+        if (*n.kind == "post") {
+            auto lambda_intro = build_capture_lambda_intro_for(n.captures, n.position(), true);
+            printer.print_cpp2(
+                "cpp2_finally_presuccess.add(" +
+                    lambda_intro + "{",
+                n.position()
+            );
+        }
+
+        //  Emit the contract group name, and report any violation to that group
+        //
+        assert(n.condition);
+        auto message = std::string{"\"\""};
+        if (n.message) {
+            message = "CPP2_CONTRACT_MSG(" + print_to_string(*n.message) + ")";
+        }
+
+        printer.print_cpp2(
+            "if (" + name + ".has_handler()",
+            n.position()
+        );
+        for (auto const& flag : n.flags) {
+            printer.print_cpp2(
+                " && " + print_to_string(*flag),
+                n.position()
+            );
+        }
+        printer.print_cpp2(
+            " && !(" + print_to_string(*n.condition) + ") ) " +
+                "{ " + name + ".report_violation(" + message + "); }",
+            n.position()
+        );
+
+        //  For a postcondition, close out the lambda
+        //
+        if (*n.kind == "post") {
+            printer.print_cpp2( "} );", n.position()
+            );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        function_type_node const& n,
+        token const*              ident,
+        bool                      is_main                    = false,
+        bool                      is_ctor_or_dtor            = false,
+        std::string               suffix1                    = {},
+        bool                      generating_postfix_inc_dec = false
+    )
+        -> void
+    {   STACKINSTR
+        if (!sema.check(n)) {
+            return;
+        }
+
+        if (
+            is_main
+            && n.parameters->parameters.size() > 0
+            )
+        {
+            printer.print_cpp2(
+                "(int const argc_, char** argv_)",
+                n.parameters->position()
+            );
+            current_functions.back().prolog.statements.push_back(
+                "auto const args = cpp2::make_args(argc_, argv_); "
+            );
+        }
+        else {
+            emit(*n.parameters, false, false, generating_postfix_inc_dec); 
+        }
+
+        //  For an anonymous function, the emitted lambda is 'constexpr' or 'mutable'
+        if (!n.my_decl->has_name())
+        {
+            if (n.my_decl->is_constexpr) {
+                //  The current design path we're trying out is for all '==' functions to be
+                //  emitted as Cpp1 'constexpr', including anonymous functions. For anonymous
+                //  functions that have captures, the intent is that '==' implies "the result
+                //  always the same (depends only on the arguments)." Specifically, the result
+                //  doesn't depend on the captured state, so the captured state should be const.
+                //  But until we want to take a dependency on post-C++20 constexpr relaxation
+                //  to make more code work with 'constexpr' even when not invoked in constexpr
+                //  contexts, we will emit it as const/whitespace instead for now.
+                //
+                //  printer.print_cpp2( " constexpr", n.position() );
+                //      // consider enabling when P2242, P2280, and similar papers are widely implemented
+            }
+            else {
+                printer.print_cpp2( " mutable", n.position() );
+            }
+        }
+
+        //  For now, adding implicit noexcept only for move/swap/dtor functions
+        if (
+            n.is_move()
+            || n.is_swap()
+            || n.is_destructor()
+            || generating_move_from == n.my_decl
+            )
+        {
+            printer.print_cpp2( " noexcept", n.position() );
+        }
+
+        printer.print_cpp2( suffix1, n.position() );
+
+        //  Handle a special member function
+        if (
+            n.is_assignment()
+            || generating_assignment_from == n.my_decl
+            )
+        {
+            assert(
+                n.returns.index() == function_type_node::empty
+                && n.my_decl->parent_declaration->name()
+            );
+            printer.print_cpp2(
+                " -> " + print_to_string( *n.my_decl->parent_declaration->name() ) + "& ",
+                n.position()
+            );
+        }
+
+        //  Otherwise, handle a default return type
+        else if (n.returns.index() == function_type_node::empty)
+        {
+            if (is_main)
+            {
+                printer.print_cpp2( " -> int", n.position() );
+            }
+            else if(!is_ctor_or_dtor)
+            {
+                printer.print_cpp2( " -> void", n.position() );
+            }
+        }
+
+        //  Otherwise, handle a single anonymous return type
+        else if (n.returns.index() == function_type_node::id)
+        {
+            auto is_type_scope_function_with_in_this =
+                n.my_decl->parent_is_type()
+                && n.parameters->ssize() > 0
+                && (*n.parameters)[0]->direction() == passing_style::in
+                ;
+
+            printer.print_cpp2( " -> ", n.position() );
+            auto& r = std::get<function_type_node::id>(n.returns);
+            assert(r.type);
+
+            auto return_type = print_to_string(*r.type);
+
+            if (r.pass == passing_style::forward) {
+                if (r.type->is_wildcard()) {
+                    printer.print_cpp2( "auto&&", n.position() );
+                }
+                else {
+                    printer.print_cpp2( return_type, n.position() );
+                    if (is_type_scope_function_with_in_this) {
+                        printer.print_cpp2( " const&", n.position() );
+                    }
+                    else if (!generating_postfix_inc_dec) {
+                        printer.print_cpp2( "&", n.position() );
+                    }
+                }
+            }
+            else {
+                printer.print_cpp2( return_type, n.position() );
+            }
+        }
+
+        //  Otherwise, handle multiple/named returns
+        else {
+            printer.print_cpp2( " -> ", n.position() );
+            function_return_name = {};
+            printer.emit_to_string(&function_return_name);
+            assert(ident);
+            printer.print_cpp2( *ident, ident->position() );
+            printer.print_cpp2( "_ret", ident->position() );
+            printer.emit_to_string();
+            printer.print_cpp2( function_return_name, ident->position() );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto is_name_declared_in_current_type_scope(std::string_view s)
+        -> bool
+    {
+        if (!s.empty())
+        {
+            //  Navigate to the enclosing type, if there is one...
+            for (auto parent = current_declarations.rbegin();
+                parent != current_declarations.rend();
+                ++parent
+                )
+            {
+                if (
+                    *parent
+                    && (*parent)->is_namespace()
+                    )
+                {
+                    break;
+                }
+                //  ... and here it is, so...
+                if (
+                    *parent
+                    && (*parent)->is_type()
+                        )
+                        {
+                            //  ... for each of its type scope decls...
+                            for (auto const& decl : (*parent)->get_type_scope_declarations())
+                            {
+                                //  ... check the name
+                                if (decl->has_name(s))
+                                {
+                                    return true;
+                                }
+                            }
+                            break;
+                }
+            }
+        }
+        return false;
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto get_enclosing_type_name()
+        -> token const*
+    {
+        //  Navigate to the enclosing type, if there is one...
+        for (auto parent = current_declarations.rbegin();
+            parent != current_declarations.rend();
+            ++parent
+            )
+        {
+            if (
+                *parent
+                && (*parent)->is_namespace()
+                )
+            {
+                break;
+            }
+            //  ... and here it is, so...
+            if (
+                *parent
+                && (*parent)->is_type()
+                )
+            {
+                return (*parent)->name();
+            }
+        }
+        return {};
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto get_enclosing_function_name()
+        -> token const*
+    {
+        //  Navigate to the enclosing function, if there is one...
+        for (auto parent = current_declarations.rbegin();
+            parent != current_declarations.rend();
+            ++parent
+            )
+        {
+            if (
+                *parent
+                && (*parent)->is_namespace()
+                )
+            {
+                break;
+            }
+            //  ... and here it is, so...
+            if (
+                *parent
+                && (*parent)->is_function()
+                )
+            {
+                return (*parent)->name();
+            }
+        }
+        return {};
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  Helper to emit type-qualified names for member functions
+    //
+    auto type_qualification_if_any_for(
+        declaration_node const& n
+    )
+        -> std::string
+    {
+        auto ret = std::string{};
+
+        if (
+            printer.get_phase() == printer.phase2_func_defs
+            && n.parent_is_type()
+//            && !n.name()->as_string_view().starts_with("operator")
+            )
+        {
+            //  If this function is inside templated type(s),
+            //  emit those outer template parameter lists too
+            auto parent = n.parent_declaration;
+            while (
+                parent
+                && parent->is_type()
+                )
+            {
+                auto list = std::string{""};
+                if (parent->template_parameters) {
+                    auto separator = std::string{"<"};
+                    for (auto& tparam : parent->template_parameters->parameters) {
+                        assert (tparam->has_name());
+                        list += separator + tparam->name()->to_string();
+                        separator = ",";
+                    }
+                    list += ">";
+                }
+                ret = print_to_string(*parent->identifier) + list + "::" + ret;
+                parent = parent->parent_declaration;
+            }
+        }
+
+        return ret;
+    }
+
+    //-----------------------------------------------------------------------
+    //  Constructors and assignment operators
+    //
+    auto emit_special_member_function(
+        declaration_node const& n,
+        std::string             prefix
+    )
+        -> void
+    {   STACKINSTR
+        assert(n.is_function());
+        auto& func = std::get<declaration_node::a_function>(n.type);
+        assert(func);
+
+        auto is_assignment =
+            generating_assignment_from == &n
+            || (*func->parameters)[0]->pass == passing_style::inout;
+
+        if (
+            func->parameters->ssize() > 1
+            && (*func->parameters)[1]->has_name("that")
+            )
+        {
+            emitting_that_function = true;
+            if (
+                (*func->parameters)[1]->pass == passing_style::move
+                || generating_move_from == &n
+                )
+            {
+                emitting_move_that_function = true;
+            }
+        }
+
+        //  Do the 'out' param and member init work only in the definition phase
+        if (printer.get_phase() == printer.phase2_func_defs)
+        {
+            auto canonize_object_name = [&]( declaration_node const* obj )
+                -> std::string
+            {
+                assert(obj->has_name());
+                auto ret = obj->name()->to_string();
+                if (ret == "this") {
+                    ret = print_to_string( *obj->get_object_type() );
+                }
+                return ret;
+            };
+
+            //  We'll use this common guidance in several errors,
+            //  so write it once to keep the guidance consistent
+            assert (n.parent_declaration && n.parent_declaration->name());
+            auto error_msg = "an operator= body must start with a series of 'member = value;' initialization statements for each of the type-scope objects in the same order they are declared, or the member must have a default initializer (in type '" + n.parent_declaration->name()->to_string() + "')";
+
+            //  If this constructor's type has data members, handle their initialization
+            //      - objects is the list of this type's declarations
+            //      - statements is the list of this constructor's statements
+            auto objects    = n.parent_declaration->get_type_scope_declarations(n.objects);
+            auto statements = n.get_initializer_statements();
+            auto out_inits  = std::vector<std::string>{};
+
+            auto object     = objects.begin();
+            auto statement  = statements.begin();
+            auto separator  = std::string{": "};
+
+            while (object != objects.end())
+            {
+                auto object_name = canonize_object_name(*object);
+
+                auto is_object_before_base =
+                    n.get_decl_if_type_scope_object_name_before_a_base_type(*(*object)->name());
+
+                auto found_explicit_init = false;
+                auto found_default_init  = false;
+                auto stmt_pos = n.position();
+
+                auto initializer = std::string{};
+
+                //  If we're at an assignment statement, get the lhs and rhs
+                if (statement != statements.end())
+                {
+                    assert (*statement);
+                    stmt_pos = (*statement)->position();
+                    if (stmt_pos.lineno < 0) {
+                        stmt_pos = n.position();
+                    }
+
+                    auto lhs = std::string{};
+                    auto rhs = std::string{};
+                    {
+                        auto exprs = (*statement)->get_lhs_rhs_if_simple_assignment();
+                        if (exprs.lhs) {
+                            if (auto tok = exprs.lhs->get_first_token_ignoring_this()) {
+                                lhs = *tok;
+                            }
+                            else {
+                                lhs = print_to_string( *exprs.lhs );
+                            }
+                        }
+                        if (exprs.rhs) {
+                            rhs = print_to_string( *exprs.rhs );
+                        }
+                    }
+
+                    //  If this is an initialization of an 'out' parameter, stash it
+                    if (n.has_out_parameter_named(lhs)){
+                        out_inits.push_back( print_to_string(**statement, false) );
+                        (*statement)->emitted = true;
+                        ++statement;
+                        continue;
+                    }
+
+                    //  Now we're ready to check whether this is an assignment to *object
+
+                    if (!lhs.empty())
+                    {
+                        //  First, see if it's an assignment 'name = something'
+                        found_explicit_init = object_name == lhs;
+
+                        //  Otherwise, see if it's 'this.name = something'
+                        if (!found_explicit_init)
+                        {
+                            //  If it's of the form 'this.name', check 'name'
+                            if (
+                                starts_with( lhs, "(*this).")
+                                && object_name == lhs.substr(8)
+                                )
+                            {
+                                found_explicit_init = true;
+                            }
+                        }
+
+                        if (found_explicit_init)
+                        {
+                            initializer = rhs;
+
+                            //  We've used this statement, so note it
+                            //  and move 'statement' forward
+                            (*statement)->emitted = true;
+                            ++statement;
+                        }
+                    }
+                }
+
+                //  Otherwise, use a default... for a non-copy/move that's the member initializer
+                //  (for which we don't need to emit anything special because it will get used),
+                //  and for a copy/move function we default to "= that.same_member" (or, if this
+                //  is a base type, to assigning from the lowered base subobject)
+                if (!found_explicit_init)
+                {
+                    if (emitting_that_function && (*object)->has_name("this"))
+                    {
+                        auto pass = std::string{" const&"};
+                        if (emitting_move_that_function) {
+                            pass = "&&";
+                        }
+                        initializer =
+                            "static_cast<"
+                            + object_name
+                            + pass
+                            + ">(that)";
+                        found_default_init = true;
+                    }
+                    else if (emitting_move_that_function)
+                    {
+                        initializer =
+                            "std::move(that)."
+                            + object_name;
+                        found_default_init = true;
+                    }
+                    else if (emitting_that_function)
+                    {
+                        initializer =
+                            "that."
+                            + object_name;
+                        found_default_init = true;
+                    }
+                    else if ((*object)->initializer)
+                    {
+                        initializer = print_to_string(*(*object)->initializer, false);
+                        found_default_init = true;
+                    }
+                }
+
+                //  If this is not an assignment to *object,
+                //  and there was no member initializer, complain
+                if (
+                    !found_explicit_init
+                    && !found_default_init
+                    )
+                {
+                    errors.emplace_back(
+                        stmt_pos,
+                        "in operator=, expected '" + object_name + " = ...' initialization statement (because type scope object '" + object_name + "' does not have a default initializer)"
+                    );
+                    errors.emplace_back(
+                        (*object)->position(),
+                        "see declaration for '" + object_name + "' here"
+                    );
+                    errors.emplace_back(
+                        stmt_pos,
+                        error_msg
+                    );
+                    return;
+                }
+
+                assert(
+                    found_explicit_init
+                    || found_default_init
+                );
+
+                //  Emit the initializer if it it isn't '_' (don't care) and ...
+                if (initializer == "_") {
+                    //  And on to the next data member...
+                    ++object;
+                    continue;
+                }
+
+                if (initializer.empty()) {
+                    initializer = "{}";
+                }
+
+                //  (a) ... if this is assignment, emit it in all cases
+                if (is_assignment)
+                {
+                    assert ((*object)->name());
+
+                    //  Flush any 'out' parameter initializations
+                    for (auto& init : out_inits) {
+                        current_functions.back().prolog.statements.push_back(init + ";");
+                    }
+                    out_inits = {};
+
+                    //  Then add this statement
+
+                    //  Use ::operator= for base classes
+                    if ((*object)->has_name("this")) {
+                        current_functions.back().prolog.statements.push_back(
+                            print_to_string( *(*object)->get_object_type() ) +
+                            "::operator= ( " +
+                            initializer +
+                            " );"
+                        );
+                    }
+                    //  Else just use infix assignment
+                    else {
+                        current_functions.back().prolog.statements.push_back(
+                            object_name +
+                            " = " +
+                            initializer +
+                            ";"
+                        );
+                    }
+                }
+                //  (b) ... if this isn't assignment, only need to emit it if it was
+                //          explicit, or is a base type or 'that' initializer
+                else if (
+                    found_explicit_init
+                    || is_object_before_base
+                    || (
+                        (*object)->has_name("this")
+                         && !initializer.empty()
+                        )
+                    || emitting_that_function
+                    )
+                {
+                    if (is_object_before_base) {
+                        assert (is_object_before_base->name());
+                        object_name =
+                            print_to_string( *is_object_before_base->parent_declaration->name() )
+                            + "_"
+                            + (*object)->name()->to_string()
+                            + "_as_base";
+                    }
+
+                    //  Flush any 'out' parameter initializations
+                    auto out_inits_with_commas = [&]() -> std::string {
+                        auto ret = std::string{};
+                        for (auto& init : out_inits) {
+                            ret += init + ", ";
+                        }
+                        out_inits = {};
+                        return ret;
+                    }();
+
+                    //  If there were any, wedge them into this initializer
+                    //  using (holds nose) the comma operator and extra parens
+                    //  as we add this statement
+                    if (!out_inits_with_commas.empty()) {
+                        current_functions.back().prolog.mem_inits.push_back(
+                            separator +
+                            object_name +
+                            "{(" +
+                            out_inits_with_commas +
+                            initializer +
+                            " )}"
+                        );
+                    }
+                    else {
+                        if (initializer == "{}") {
+                            initializer = "";
+                        }
+                        current_functions.back().prolog.mem_inits.push_back(
+                            separator +
+                            object_name +
+                            "{ " +
+                            initializer +
+                            " }"
+                        );
+                    }
+                    separator = ", ";
+                }
+
+                //  And on to the next data member...
+                ++object;
+            }
+
+            //  Now no data members should be left over
+            if (object != objects.end())
+            {
+                errors.emplace_back(
+                    (*object)->position(),
+                    canonize_object_name(*object) + " was not initialized - did you forget to write a default initializer, or assign to it in the operator= body?"
+                );
+                errors.emplace_back(
+                    (*object)->position(),
+                    "see declaration for '" + canonize_object_name(*object) + "' here"
+                );
+                errors.emplace_back(
+                    (*object)->position(),
+                    error_msg
+                );
+                return;
+            }
+
+            //  Flush any possible remaining 'out' parameters
+            for (auto& init : out_inits) {
+                current_functions.back().prolog.statements.push_back(init + ";");
+            }
+        }
+
+        //  For a constructor, print the type name instead of the operator= function name
+        assert(n.parent_is_type());
+        if (!is_assignment)
+        {
+            printer.print_cpp2( prefix, n.position() );
+            printer.print_cpp2( type_qualification_if_any_for(n), n.position() );
+            printer.print_cpp2( print_to_string( *n.parent_declaration->name() ), n.position() );
+            emit( *func, n.name(), false, true );
+        }
+        //  For an assignment operator, similar to emitting an ordinary function
+        else
+        {
+            assert (!current_functions.empty());
+            current_functions.back().epilog.push_back( "return *this;");
+            printer.print_cpp2( prefix, n.position() );
+            printer.print_cpp2( "auto " + type_qualification_if_any_for(n) + print_to_string( *n.name() ), n.position());
+            emit( *func, n.name() );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //
+    auto emit(
+        declaration_node const& n,
+        std::string const&      capture_intro = {}
+    )
+        -> void
+    {   STACKINSTR
+        // Helper for declarations with parent *template-head*s.
+        auto const emit_parent_template_parameters = [&]() {
+            auto parent_template_parameters = std::string{};
+            auto parent = n.parent_declaration;
+            while (
+                parent
+                && parent->is_type()
+                )
+            {
+                if (parent->requires_clause_expression) {
+                    parent_template_parameters =
+                        "requires( " + print_to_string(*parent->requires_clause_expression) + " )\n"
+                        + parent_template_parameters;
+                }
+                if (parent->template_parameters) {
+                    parent_template_parameters =
+                        "template " + print_to_string( *parent->template_parameters, false, true )
+                        + " " + parent_template_parameters;
+                }
+                parent = parent->parent_declaration;
+            }
+            printer.print_cpp2(parent_template_parameters, n.position());
+        };
+
+        //  Helper for declarations that can have requires-clauses
+        auto const emit_requires_clause = [&]() {
+            if (
+                n.requires_clause_expression
+                || !function_requires_conditions.empty()
+                )
+            {
+                printer.print_extra("\n");
+                printer.ignore_alignment( true, n.position().colno + 4 );
+                if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                    // Workaround GCC 10 not supporting requires in forward declarations in some cases.
+                    // See commit 5a0d77f8e297902c0b9712c5aafb6208cfa4c139.
+                    if (n.is_object() || n.parent_is_type()) {
+                        printer.print_extra("CPP2_REQUIRES_ (");
+                    }
+                    else {
+                        printer.print_extra("CPP2_REQUIRES (");
+                    }
+                }
+                else {
+                    printer.print_extra("requires (");
+                }
+
+                if (n.requires_clause_expression) {
+                    emit(*n.requires_clause_expression);
+                    if (!function_requires_conditions.empty()) {
+                        printer.print_extra(" && ");
+                    }
+                }
+
+                if (!function_requires_conditions.empty()) {
+                    printer.print_extra(function_requires_conditions.front());
+                    for (auto it = std::cbegin(function_requires_conditions)+1; it != std::cend(function_requires_conditions); ++it) {
+                        printer.print_extra(" && " + *it);
+                    }
+                }
+
+                printer.print_extra(") ");
+                function_requires_conditions = {};
+                printer.ignore_alignment( false );
+            }
+        };
+
+
+        //  Declarations are handled in multiple passes,
+        //  but we only want to do the sema checks once
+        if (
+            printer.get_phase() == printer.phase2_func_defs
+            && !sema.check(n)
+            )
+        {
+            return;
+        }
+
+        //  In phase 0, only need to consider namespaces and types
+
+        if (
+            printer.get_phase() == printer.phase0_type_decls
+            && !n.is_namespace()
+            && !n.is_type()
+            )
+        {
+            return;
+        }
+
+        //  If this is a generated declaration (negative source line number),
+        //  add a line break before
+        if (
+            printer.get_phase() == printer.phase2_func_defs
+            && n.position().lineno < 1
+            )
+        {
+            printer.print_extra("\n");
+        }
+
+        auto guard0 = stack_value(having_signature_emitted, &n);
+        auto guard1 = stack_element(current_declarations, &n);
+        current_names.push_back(&n);
+        auto guard2 = stack_size_if(current_names, n.is_function());
+
+        //  Handle aliases
+
+        if (n.is_alias())
+        {
+            auto& a = std::get<declaration_node::an_alias>(n.type);
+            assert(a);
+
+            //  Namespace-scope aliases are emitted in phase 1,
+            //  type-scope object aliases in both phases 1 and 2, and
+            //  function-scope aliases in phase 2
+            if (
+                (
+                    !n.parent_is_function()
+                    && printer.get_phase() == printer.phase1_type_defs_func_decls
+                    )
+                ||
+                (
+                    n.parent_is_type()
+                    && n.is_object_alias()
+                    && printer.get_phase() == printer.phase2_func_defs
+                    )
+                ||
+                (
+                    n.parent_is_function()
+                    && printer.get_phase() == printer.phase2_func_defs
+                    )
+                )
+            {
+                assert(
+                    a->is_type_alias()
+                    || a->is_namespace_alias()
+                    || a->is_object_alias()
+                );
+
+                //  If we're in a type scope, handle the access specifier
+                if (
+                    n.parent_is_type()
+                    && printer.get_phase() == printer.phase1_type_defs_func_decls
+                    )
+                {
+                    if (!n.is_default_access()) {
+                        printer.print_cpp2(to_string(n.access) + ": ", n.position());
+                    }
+                    else {
+                        printer.print_cpp2("public: ", n.position());
+                    }
+                }
+
+                //  Emit template parameters if any
+                if (
+                    a->is_object_alias()
+                    && n.parent_is_type()
+                    && printer.get_phase() == printer.phase2_func_defs
+                    )
+                {
+                    emit_parent_template_parameters();
+                }
+
+                if (n.template_parameters) {
+                    printer.print_cpp2("template", n.position());
+                    emit(*n.template_parameters, false, true);
+                    printer.print_cpp2(" ", n.position());
+                }
+
+                //  Emit requires clause if any
+                emit_requires_clause();
+
+                //  Handle type aliases
+                if (a->is_type_alias()) {
+                    printer.print_cpp2(
+                        "using "
+                            + print_to_string(*n.identifier)
+                            + " = "
+                            + print_to_string( *std::get<alias_node::a_type>(a->initializer) )
+                            + ";\n",
+                        n.position()
+                    );
+                }
+
+                //  Handle namespace aliases
+                else if (a->is_namespace_alias()) {
+                    printer.print_cpp2(
+                        "namespace "
+                            + print_to_string(*n.identifier)
+                            + " = "
+                            + print_to_string( *std::get<alias_node::a_namespace>(a->initializer) )
+                            + ";\n",
+                        n.position()
+                    );
+                }
+
+                //  Handle object aliases:
+                //      - at function scope, it's const&
+                //      - at namespace scope, it's inline constexpr
+                //      - at type scope, it's also inline constexpr but see note (*) below
+                else if (a->is_object_alias())
+                {
+                    auto type = std::string{"auto"};
+                    if (a->type_id) {
+                        type = print_to_string(*a->type_id);
+                    }
+
+                    //  (*) If this is at type scope, Cpp1 requires an out-of-line declaration dance
+                    //  for some cases to work - see https://stackoverflow.com/questions/11928089/
+                    if (n.parent_is_type())
+                    {
+                        assert (n.parent_declaration->name());
+
+                        if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                            printer.print_cpp2(
+                                "static const "
+                                    + type + " "
+                                    + print_to_string(*n.identifier)
+                                    + ";\n",
+                                n.position()
+                            );
+                        }
+                        else if (printer.get_phase() == printer.phase2_func_defs) {
+                            //  The following logic is not yet complete, so give a diagnostic for now
+                            if (n.parent_declaration->parent_is_type()) {
+                                errors.emplace_back(
+                                    n.position(),
+                                    "(temporary alpha limitation) an object alias cannot yet appear inside a nested type"
+                                );
+                                return;
+                            }
+
+                            printer.print_cpp2(
+                                "inline CPP2_CONSTEXPR "
+                                    + type
+                                    + " "
+                                    + type_qualification_if_any_for(n)
+                                    + print_to_string(*n.identifier)
+                                    + " = "
+                                    + print_to_string( *std::get<alias_node::an_object>(a->initializer) )
+                                    + ";\n",
+                                n.position()
+                            );
+                        }
+                    }
+                    //  Otherwise, at function and namespace scope we can just define
+                    else
+                    {
+                        auto intro = std::string{};
+                        if (n.parent_is_function()) {
+                            intro = "constexpr";
+                        }
+                        else if (n.parent_is_namespace()) {
+                            intro = "inline constexpr";
+                        }
+
+                        printer.print_cpp2(
+                            type + " "
+                                + intro + " "
+                                + print_to_string(*n.identifier)
+                                + " = "
+                                + print_to_string( *std::get<alias_node::an_object>(a->initializer) )
+                                + ";\n",
+                            n.position()
+                        );
+                    }
+                }
+
+                else {
+                    assert(!"ICE: should be unreachable - invalid alias");
+                }
+
+                return;
+            }
+        }
+
+
+        //  Handle other declarations
+
+        auto need_to_generate_assignment      = false;
+        auto need_to_generate_move            = false;
+        auto need_to_generate_postfix_inc_dec = false;
+
+        if (
+            n.is_function()
+            && n.has_name()
+            )
+        {   // reset the 'that' flags
+            emitting_that_function      = false;
+            emitting_move_that_function = false;
+            already_moved_that_members  = {};
+        }
+
+        auto is_main =
+            !n.parent_declaration
+            && n.has_name("main")
+            ;
+        auto is_in_type = n.parent_is_type();
+
+        if (!check_shadowing_of_type_scope_names(n)) {
+            return;
+        }
+
+
+        //  If this is a function that has multiple return values,
+        //  first we need to emit the struct that contains the returns
+        if (
+            printer.get_phase() == printer.phase1_type_defs_func_decls
+            && n.is_function()
+            )
+        {
+            auto& func = std::get<declaration_node::a_function>(n.type);
+            assert(func);
+
+            if (func->returns.index() == function_type_node::list)
+            {
+                auto& r = std::get<function_type_node::list>(func->returns);
+                assert(r);
+                assert(std::ssize(r->parameters) > 0);
+
+                auto func_name = n.name()->to_string();
+
+                //  If it's a single named value, emit it as an anonymous return value
+                if (std::ssize(r->parameters) == 1)
+                {
+                    printer.print_extra(
+                        "\nusing "
+                        + func_name + "_ret = "
+                        + r->parameters[0]->declaration->get_object_type()->to_string()
+                        + ";"
+                    );
+                }
+                //  Else just emit it as an ordinary struct
+                else
+                {
+                    printer.print_extra(
+                        "\nstruct "
+                        + n.name()->to_string()
+                        + "_ret "
+                    );
+                    emit(*r, true);
+                }
+                printer.print_extra( "\n" );
+            }
+        }
+
+        //  If this is a class definition that has data members before bases,
+        //  first we need to emit the aggregate that contains the members
+        if (
+            n.is_type()
+            && printer.get_phase() == printer.phase1_type_defs_func_decls
+            )
+        {
+            assert(
+                n.initializer
+                && n.initializer->is_compound()
+            );
+            auto& compound_stmt = std::get<statement_node::compound>(n.initializer->statement);
+
+            assert(compound_stmt);
+            auto found = false;
+
+            for (auto& stmt : compound_stmt->statements)
+            {
+                if (stmt->is_declaration())
+                {
+                    auto& decl = std::get<statement_node::declaration>(stmt->statement);
+                    assert(decl);
+                    assert(decl->name());
+
+                    auto emit_as_base =
+                        decl->get_decl_if_type_scope_object_name_before_a_base_type(*decl->name());
+
+                    if (emit_as_base) {
+                        printer.print_extra(
+                            "\nstruct "
+                                + print_to_string(*decl->parent_declaration->name())
+                                + "_"
+                                + decl->name()->to_string()
+                                + "_as_base { "
+                                + print_to_string( *decl->get_object_type() )
+                                + " "
+                                + decl->name()->to_string()
+                                + "; };"
+                        );
+                        found = true;
+                    }
+                }
+            }
+
+            if (found) {
+                printer.print_extra("\n");
+            }
+        }
+
+        //  In class definitions, emit the explicit access specifier if there
+        //  is one, or default to private for data and public for functions
+        if (printer.get_phase() == printer.phase1_type_defs_func_decls)
+        {
+            if (!n.is_default_access()) {
+                assert (is_in_type);
+                printer.print_cpp2(to_string(n.access) + ": ", n.position());
+            }
+            else if (is_in_type) {
+                if (n.is_object()) {
+                    printer.print_cpp2("private: ", n.position());
+                }
+                else {
+                    printer.print_cpp2("public: ", n.position());
+                }
+            }
+        }
+
+        //  If this is a function definition and the function is inside
+        //  type(s) that have template parameters and/or requires clauses,
+        //  emit those outer template parameters and requires clauses too
+        if (
+            printer.get_phase() == printer.phase2_func_defs
+            && n.is_function()
+            && n.initializer    // only if the function has a definition (is not abstract)
+            )
+        {
+            emit_parent_template_parameters();
+        }
+
+        //  Now, emit our own template parameters
+        if (
+            n.template_parameters
+            && (
+                printer.get_phase() <  printer.phase2_func_defs
+                || n.is_object()
+                || (
+                    n.is_function()
+                    && n.has_name()     // only if it is not unnamed function aka lambda
+                    && n.initializer    // only if the function has a definition (is not abstract)
+                    && printer.get_phase() == printer.phase2_func_defs
+                    )
+                )
+            && (
+                !n.is_concept()
+                || printer.get_phase() == printer.phase1_type_defs_func_decls
+                )
+            )
+        {
+            printer.print_cpp2("template", n.position());
+            emit(*n.template_parameters, false, true);
+            printer.print_cpp2(" ", n.position());
+        }
+
+        //  User-defined type
+        if (n.is_type())
+        {
+            assert(
+                n.initializer
+                && n.initializer->is_compound()
+            );
+            auto& compound_stmt = std::get<statement_node::compound>(n.initializer->statement);
+
+            if (printer.get_phase() != printer.phase2_func_defs)
+            {
+                if (n.requires_clause_expression) {
+                    printer.print_cpp2("requires( ", n.requires_pos);
+                    emit(*n.requires_clause_expression);
+                    printer.print_cpp2(" )\n", n.requires_pos);
+                }
+
+                printer.print_cpp2("class ", n.position());
+                emit(*n.identifier);
+
+                //  Type declaration
+                if (printer.get_phase() == printer.phase0_type_decls) {
+                    printer.print_cpp2( ";\n", n.position() );
+                    return;
+                }
+            }
+
+            if (
+                n.is_type_final()
+                && printer.get_phase() == printer.phase1_type_defs_func_decls
+                )
+            {
+                printer.print_cpp2( " final", n.position() );
+            }
+
+            //  Type definition
+            auto separator              = std::string{":"};
+            auto started_body           = false;
+            auto saved_for_body         = std::vector<std::pair<std::string, source_position>>{};
+            auto found_constructor      = false;
+            auto found_that_constructor = false;
+            assert(compound_stmt);
+
+            auto start_body = [&]{
+                if (!started_body) {
+                    printer.print_cpp2(" {", compound_stmt->position());
+                    started_body = true;
+                    for (auto& [line, pos] : saved_for_body) {
+                        printer.print_cpp2(line + "\n", pos);
+                    }
+                }
+            };
+
+            for (auto& stmt : compound_stmt->statements)
+            {
+                assert(stmt);
+                if (
+                    !stmt->is_declaration()
+                    && !stmt->is_using()
+                    )
+                {
+                    //  We will already have emitted an error for this in sema.check
+                    return;
+                }
+
+                //  If it's a using statement, save it up if we haven't started the body yet
+
+                if (stmt->is_using()) {
+                    auto& use = std::get<statement_node::using_>(stmt->statement);
+                    assert(use);
+                    if (started_body) {
+                        emit(*use);
+                    }
+                    else {
+                        saved_for_body.emplace_back( print_to_string(*use), use->position() );
+                    }
+                    continue;
+                }
+
+                //  Else it's a declaration...
+
+                auto& decl = std::get<statement_node::declaration>(stmt->statement);
+                assert(decl);
+
+                if (
+                    decl->is_alias()
+                    && printer.get_phase() == printer.phase1_type_defs_func_decls
+                    )
+                {
+                    if (started_body) {
+                        emit(*decl);
+                    }
+                    else {
+                        saved_for_body.emplace_back( print_to_string(*decl), decl->position() );
+                    }
+                    continue;
+                }
+
+                if (decl->is_constructor()) {
+                    found_constructor = true;
+                }
+                if (decl->is_constructor_with_that()) {
+                    found_that_constructor = true;
+                }
+
+                //  First we'll encounter the base types == subobjects named "this"
+                //  and any data members declared before them that we push into private bases
+                assert(decl->name());
+                auto emit_as_base =
+                    decl->get_decl_if_type_scope_object_name_before_a_base_type(*decl->name())
+                    || decl->has_name("this")
+                    ;
+                if (emit_as_base)
+                {
+                    //  Do the sema check for these declarations here, because we're
+                    //  handling them here instead of going through emit() for them
+                    if (!sema.check(*decl)) {
+                        return;
+                    }
+
+                    if (decl->has_name("this")) {
+                        if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                            printer.print_cpp2(
+                                separator + " public " + print_to_string(*decl->get_object_type()),
+                                compound_stmt->position()
+                            );
+                            separator = ",";
+                        }
+                    }
+                    else
+                    {
+                        if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                            printer.print_cpp2(
+                                separator
+                                    + " public "
+                                    + print_to_string(*decl->parent_declaration->name())
+                                    + "_"
+                                    + decl->name()->to_string()
+                                    + "_as_base",
+                                compound_stmt->position()
+                            );
+                            separator = ",";
+                        }
+                    }
+                }
+                //  Then we'll switch to start the body == other members
+                else
+                {
+                    if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                        start_body();
+                    }
+                    emit(*decl);
+                }
+            }
+
+            if (printer.get_phase() == printer.phase1_type_defs_func_decls)
+            {
+                //  Ensure we emit the { even if there are only bases in the type
+                start_body();
+
+                auto id     = print_to_string(*n.identifier);
+                auto indent = static_cast<size_t>(
+                                std::clamp(
+                                    compound_stmt->body_indent,
+                                    n.position().colno,
+                                    n.position().colno + 5      // sanity check
+                                    )
+                                );
+                auto prefix = "\n" + std::string( indent, ' ' ) + "public: ";
+
+                if (n.member_function_generation)
+                {
+                    //  If no constructor was defined, there should only be
+                    //  a default constructor, so generate that
+                    if (!found_constructor) {
+                        printer.print_extra( prefix + id + "() = default;" );
+                    }
+
+                    //  If no 'that' constructor was defined, disable copy/move
+                    //  so that Cpp1 doesn't silently generate it anyway
+                    if (!found_that_constructor) {
+                        printer.print_extra( prefix + id + "(" + id + " const&) = delete; /* No 'that' constructor, suppress copy */" );
+                        printer.print_extra( prefix + "auto operator=(" + id + " const&) -> void = delete;" );
+                    }
+
+                    if (!found_constructor || !found_that_constructor) {
+                        printer.print_extra( "\n" );
+                    }
+                }
+
+                printer.print_cpp2("};\n", compound_stmt->close_brace);
+            }
+        }
+
+
+        //  Namespace
+        if (n.is_namespace())
+        {
+            printer.print_cpp2("namespace ", n.position());
+
+            //  "_" is the anonymous namespace, which is just whitespace in Cpp1
+            if (auto tok = n.identifier->get_token();
+                tok
+                && *tok != "_"
+                )
+            {
+                emit(*n.identifier);
+            }
+
+            assert(
+                n.initializer
+                && n.initializer->is_compound()
+            );
+            auto& compound_stmt = std::get<statement_node::compound>(n.initializer->statement);
+
+            printer.print_cpp2(" {", compound_stmt->position());
+
+            assert(compound_stmt);
+            for (auto& stmt : compound_stmt->statements) {
+                assert(stmt);
+                if (stmt->is_declaration()) {
+                    auto& decl = std::get<statement_node::declaration>(stmt->statement);
+                    assert(decl);
+                    emit(*decl);
+                }
+                else if (stmt->is_using()) {
+                    auto& use = std::get<statement_node::using_>(stmt->statement);
+                    assert(use);
+                    emit(*use);
+                }
+                else {
+                    errors.emplace_back(
+                        stmt->position(),
+                        "a namespace scope must contain only declarations or 'using' statements, not other code"
+                    );
+                    return;
+                }
+            }
+
+            printer.print_cpp2("}\n", compound_stmt->close_brace);
+        }
+
+        //  Function
+        else if (
+            n.is_function()
+            && (
+                printer.get_phase() < printer.phase2_func_defs
+                || n.initializer    // only emit definition if the function has one (is not abstract)
+                || n.is_defaultable_function()
+                )
+            )
+        {
+            auto is_streaming_operator = [](std::string_view sv) {
+                return
+                    sv == "operator<<"
+                    || sv == "operator>>"
+                    ;
+                };
+
+            auto is_binary_arithmetic_operator = [](std::string_view sv) {
+                return
+                    sv == "operator+"
+                    || sv == "operator-"
+                    || sv == "operator*"
+                    || sv == "operator/"
+                    || sv == "operator%"
+                    ;
+                };
+
+            auto emit_as_friend =
+                n.name()
+                && (
+                    is_streaming_operator( n.name()->as_string_view() )
+                    || (!n.is_function_with_this() && is_binary_arithmetic_operator( n.name()->as_string_view() ))
+                    )
+                ;
+
+            //  Start fresh (there may be one spurious leftover
+            //  requires-condition created during the declarations pass)
+            function_requires_conditions = {};
+
+            auto& func = std::get<declaration_node::a_function>(n.type);
+            assert(func);
+
+            current_functions.push(
+                &n,
+                func.get(),
+                n.find_parent_declared_value_set_functions()
+                );
+            auto guard0 = finally([&]{ current_functions.pop(); });
+
+            auto guard1 = stack_size(current_names);
+
+            //  If this is at expression scope, we can't emit "[[nodiscard]] auto name"
+            //  so print the provided intro instead, which will be a Cpp1 lambda-introducer
+            if (capture_intro != "")
+            {
+                assert (!n.identifier);
+                printer.print_cpp2(capture_intro, n.position());
+                emit( *func, nullptr, is_main);
+            }
+
+            //  Else start introducing a normal function
+            else
+            {
+                assert (n.identifier);
+
+                //  Handle member functions
+                std::string prefix  = {};
+                std::string suffix1 = {};
+                std::string suffix2 = {};
+
+                if (n.is_constexpr) {
+                    prefix += "constexpr ";
+                }
+
+                if (
+                    !n.has_initializer()
+                    && n.is_defaultable_function()
+                    )
+                {
+                    suffix2 += " = default";
+                }
+
+                //  If there's a 'this' parameter, handle it here (the parameter emission will skip it)
+                //  because Cpp1 syntax requires its information to be spread around the declaration syntax
+                assert (func->parameters);
+                if (
+                    !func->parameters->parameters.empty()
+                    && func->parameters->parameters[0]->declaration->has_name("this")
+                    )
+                {
+                    assert (is_in_type);
+                    auto& this_ = func->parameters->parameters[0];
+
+                    switch (this_->pass) {
+                    break;case passing_style::in:
+                        suffix1 += " const";
+                        //  Cpp1 ref-qualifiers don't belong on virtual functions
+                        if (!this_->is_polymorphic()) {
+                            suffix1 += "&";
+                        }
+                    break;case passing_style::inout:
+                        //  Cpp1 ref-qualifiers don't belong on virtual functions
+                        if (!this_->is_polymorphic()) {
+                            suffix1 += " &";
+                        }
+                    break;case passing_style::out:
+                        ; // constructor is handled below
+                    break;case passing_style::move:
+                        suffix1 += " &&";
+
+                    //  We shouldn't be able to get into a state where these values
+                    //  exist here, if we did it's our compiler bug
+                    break;case passing_style::copy:
+                          case passing_style::forward:
+                          default:
+                        errors.emplace_back( n.position(), "ICE: invalid parameter passing style, should have been rejected", true);
+                    }
+
+                    //  Note: Include a phase check because Cpp1 does not allow
+                    //        these on out-of-line definitions
+                    if (printer.get_phase() != printer.phase2_func_defs)
+                    {
+                        switch (this_->mod) {
+                        break;case parameter_declaration_node::modifier::implicit:
+                            ;
+                        break;case parameter_declaration_node::modifier::virtual_:
+                            prefix += "virtual ";
+                            if (!n.initializer) {
+                                suffix2 += " = 0";
+                            }
+                        break;case parameter_declaration_node::modifier::override_:
+                            suffix2 += " override";
+                        break;case parameter_declaration_node::modifier::final_:
+                            suffix2 += " final";
+                        break;default:
+                            if (
+                                func->is_constructor()
+                                && !func->is_constructor_with_that()
+                                && generating_assignment_from != &n
+                                )
+                            {
+                                prefix += "explicit ";
+                            }
+                        }
+                    }
+                }
+                //  Else if there isn't a 'this' parameter, but this function is in a type scope,
+                //  it's a Cpp1 non-member function so we need to say so (on the declaration only)
+                else if (
+                    is_in_type
+                    && printer.get_phase() != printer.phase2_func_defs
+                    ) {
+                    if (emit_as_friend) {
+                        prefix += "friend ";
+                    }
+                    else {
+                        prefix += "static ";
+                    }
+                }
+
+                //  If there's a return type, it's [[nodiscard]] implicitly and all the time
+                //  -- for now there's no opt-out, wait and see whether we actually need one
+                if (
+                    func->has_non_void_return_type()
+                    && !func->is_assignment()
+                    && !func->is_compound_assignment()
+                    && !func->is_increment_or_decrement()
+                    && (
+                        printer.get_phase() == printer.phase1_type_defs_func_decls
+                        || n.has_initializer()  // so we're printing it in phase 2
+                        )
+                    && (
+                        !emit_as_friend         // can't have an attribute on a friend declaration-not-definition
+                        || printer.get_phase() != printer.phase1_type_defs_func_decls
+                        )
+                    && !(
+                        n.name()
+                        && is_streaming_operator(n.name()->as_string_view())
+                        )
+                    )
+                {
+                    printer.print_cpp2( "[[nodiscard]] ", n.position() );
+                }
+
+                //  Now we have all the pieces we need for the Cpp1 function declaration
+
+                //  For a special member function, we need to do more work to translate
+                //  in-body initialization statements to the Cpp1 mem-init-list syntax
+                if (
+                    n.is_constructor()
+                    || n.is_assignment()
+                    )
+                {
+                    assert(
+                        !is_main
+                        && suffix2.empty()
+                        && "ICE: an operator= shouldn't have been able to generate a suffix (or be main)"
+                    );
+
+                    emit_special_member_function(
+                        n,
+                        prefix
+                    );
+
+                    //  If there's no inheritance and this operator= has two parameters,
+                    //  it's setting from a single value -- either from the same type
+                    //  (aka copy/move) or another type (a conversion) -- so recurse to
+                    //  emit related functions if the user didn't write them by hand
+                    if (
+                        !n.parent_is_polymorphic()
+                        && func->parameters->ssize() == 2
+                        && generating_assignment_from != &n
+                        )
+                    {
+                        assert(!current_functions.empty());
+
+                        //  A)  Generate (A)ssignment from a constructor,
+                        //      if the user didn't write the assignment function themselves
+                        if (
+                            //  A1) This is '(out   this, that)'
+                            //      and no  '(inout this, that)' was written by the user
+                            (
+                                &n == current_functions.back().declared_value_set_functions.out_this_in_that
+                                && !current_functions.back().declared_value_set_functions.inout_this_in_that
+                                )
+                            ||
+                            //  A2) This is '(out   this, move that)'
+                            //      and no  '(inout this, move that)' was written by the user
+                            //  (*) and no  '(inout this,      that)' was written by the user (*)
+                            //
+                            //  (*) This third test is to tie-break M2 and A2 in favor of M2. Both M2 and A2
+                            //      can generate a missing '(inout this, move that)', and if we have both
+                            //      options then we should prefer to use M2 (generate move assignment from
+                            //      copy assignment) rather than A2 (generate move assignment from move
+                            //      construction) as M2 is a better fit (move assignment is more like copy
+                            //      assignment than like move construction, because assignments are designed
+                            //      structurally to set the value of an existing 'this' object)
+                            (
+                                &n == current_functions.back().declared_value_set_functions.out_this_move_that
+                                && !current_functions.back().declared_value_set_functions.inout_this_move_that
+                                && !current_functions.back().declared_value_set_functions.inout_this_in_that
+                                )
+                            ||
+                            //  A3) This is '(out   this, something-other-than-that)'
+                            (
+                                n.is_constructor()
+                                && !n.is_constructor_with_that()
+                                && !contains( current_functions.back().declared_value_set_functions.assignments_from, n.nth_parameter_type_name(2) )
+                                )
+                            )
+                        {
+                            need_to_generate_assignment = true;
+                        }
+
+                        if (generating_move_from != &n) {
+
+                            //  M)  Generate (M)ove from copy,
+                            //      if the user didn't write the move function themselves
+                            if (
+                                //  M1) This is '(out   this,      that)'
+                                //      and no  '(out   this, move that)' was written by the user
+                                (
+                                    &n == current_functions.back().declared_value_set_functions.out_this_in_that
+                                    && !current_functions.back().declared_value_set_functions.out_this_move_that
+                                    )
+                                ||
+                                //  M2) This is '(inout this,      that)'
+                                //      and no  '(inout this, move that)' was written by the user
+                                (
+                                    &n == current_functions.back().declared_value_set_functions.inout_this_in_that
+                                    && !current_functions.back().declared_value_set_functions.inout_this_move_that
+                                    )
+                                )
+                            {
+                                need_to_generate_move = true;
+                            }
+
+                        }
+                    }
+                }
+
+                //  For a destructor, we need to translate
+                else if (n.is_destructor())
+                {
+                    assert(
+                        !is_main
+                        // prefix can be "virtual"
+                        // suffix1 will be " &&" though we'll ignore that
+                        // suffix2 can be "= 0"
+                    );
+
+                    //  Print the ~-prefixed type name instead of the operator= function name
+                    assert(
+                        n.parent_is_type()
+                        && n.parent_declaration->name()
+                    );
+                    printer.print_cpp2(
+                        prefix
+                            + type_qualification_if_any_for(n)
+                            + "~" + print_to_string(*n.parent_declaration->name()),
+                        n.position()
+                    );
+                    emit( *func, n.name(), false, true);
+                    printer.print_cpp2( suffix2, n.position() );
+                }
+
+                //  Ordinary functions are easier, do all their declarations except
+                //  don't emit abstract virtual functions in phase 2
+                else if (
+                    n.initializer
+                    || printer.get_phase() < printer.phase2_func_defs
+                    )
+                {
+                    printer.print_cpp2( prefix, n.position() );
+                    printer.print_cpp2( "auto ", n.position() );
+                    if (
+                        !emit_as_friend
+                        || printer.get_phase() != printer.phase2_func_defs
+                        )
+                    {
+                        printer.print_cpp2( type_qualification_if_any_for(n), n.position() );
+                    }
+
+                    emit( *n.name() );
+                    emit( *func, n.name(), is_main, false, suffix1, generating_postfix_inc_dec_from != nullptr );
+                    printer.print_cpp2( suffix2, n.position() );
+
+                    //  If this is ++ or --, also generate a Cpp1 postfix version of the operator
+                    if (func->is_increment_or_decrement())
+                    {
+                        if (generating_postfix_inc_dec_from) {
+                            assert (generating_postfix_inc_dec_from == &n);
+                        }
+                        else {
+                            need_to_generate_postfix_inc_dec = true;
+                        }
+                    }
+                }
+            }
+
+            //  If we're only emitting declarations, end the function declaration
+            if (
+                printer.get_phase() == printer.phase1_type_defs_func_decls
+                && !n.is_function_expression()
+                )
+            {
+                emit_requires_clause();
+                if (n.position().lineno < 0) {
+                    printer.print_cpp2( ";\n", n.position() );
+                }
+                else {
+                    printer.print_cpp2( ";", n.position() );
+                }
+
+                //  Note: Not just early "return;" here because we may need
+                //  to recurse to emit generated operator declarations too,
+                //  so all the definition work goes into a big 'else' branch
+            }
+
+            //  Else emit the definition
+            else if (n.initializer)
+            {
+                if (func->returns.index() == function_type_node::list) {
+                    auto& r = std::get<function_type_node::list>(func->returns);
+                    function_returns.emplace_back(r.get());
+                }
+                else if (func->returns.index() == function_type_node::id) {
+                    function_returns.emplace_back(
+                        &single_anon,               // use special value as a note
+                        std::get<function_type_node::id>(func->returns).pass,
+                        std::get<function_type_node::id>(func->returns).type->is_wildcard()
+                    );
+                }
+                else {
+                    function_returns.emplace_back(nullptr);        // no return type at all
+                }
+
+                if (func->has_postconditions()) {
+                    current_functions.back().prolog.statements.push_back("cpp2::finally_presuccess cpp2_finally_presuccess;");
+                }
+
+                if (func->returns.index() == function_type_node::list)
+                {
+                    auto& r = std::get<function_type_node::list>(func->returns);
+                    assert(r);
+                    for (auto& param : r->parameters)
+                    {
+                        assert(param && param->declaration);
+                        auto& decl    = *param->declaration;
+
+                        assert(decl.is_object());
+                        auto& id_expr = std::get<declaration_node::an_object>(decl.type);
+                        assert(id_expr);
+
+                        auto loc = std::string{};
+                        if (!decl.initializer) {
+                            loc += ("    cpp2::deferred_init<");
+                        }
+
+                        //  For convenience, just capture the id-expression as a string
+                        printer.emit_to_string(&loc);
+                        emit(*id_expr);
+                        printer.emit_to_string();
+
+                        if (!decl.initializer) {
+                            loc += (">");
+                        }
+                        loc += " ";
+                        loc += decl.name()->as_string_view();
+                        if (decl.initializer)
+                        {
+                            std::string init;
+                            printer.emit_to_string(&init);
+                            printer.print_cpp2 ( " {", decl.initializer->position() );
+                            if (!decl.initializer->is_expression()) {
+                                errors.emplace_back(
+                                    decl.initializer->position(),
+                                    "return value initializer must be an expression"
+                                );
+                                return;
+                            }
+                            auto& expr = std::get<statement_node::expression>(decl.initializer->statement);
+                            assert(expr);
+
+                            emit(*expr, false);
+                            printer.print_cpp2 ( "}", decl.initializer->position() );
+                            printer.emit_to_string();
+
+                            loc += init;
+                        }
+                        loc += ";";
+                        current_functions.back().prolog.statements.push_back(loc);
+                    }
+                }
+
+                for (auto&& c : func->contracts)
+                {
+                    auto print = std::string();
+                    printer.emit_to_string(&print);
+                    auto guard = stack_value(having_signature_emitted, nullptr);
+                    emit(*c);
+                    printer.emit_to_string();
+                    current_functions.back().prolog.statements.push_back(print);
+                }
+
+                printer.preempt_position_push( n.equal_sign );
+
+                emit_requires_clause();
+
+                having_signature_emitted = nullptr;
+
+                //  If this is ++ or --, also generate a Cpp1 postfix version of the operator
+                if (generating_postfix_inc_dec_from)
+                {
+                    assert (generating_postfix_inc_dec_from == &n);
+
+                    auto param1 = std::string{"*this"};
+                    if (
+                        !n.parent_declaration
+                        || !n.parent_declaration->is_type()
+                        )
+                    {
+                        param1 = n.first_parameter_name();
+                    }
+
+                    printer.print_cpp2(
+                        " { auto ret = " + param1 + "; ++" + param1 + "; return ret; }",
+                        n.position()
+                    );
+                }
+                //  Else just emit the normal function body
+                else {
+                    emit(
+                        *n.initializer,
+                        true, func->position(), func->returns.index() == function_type_node::empty,
+                        current_functions.back().prolog,
+                        current_functions.back().epilog
+                    );
+                }
+
+                printer.preempt_position_pop();
+
+                function_returns.pop_back();
+            }
+
+            //  Finally, do the potential recursions...
+
+            //  If this was a constructor and we want also want to emit
+            //  it as an assignment operator, do it via a recursive call
+            if (need_to_generate_assignment)
+            {
+                //  Reset the 'emitted' flags
+                for (auto& statement : n.get_initializer_statements()) {
+                    statement->emitted = false;
+                }
+
+                //  Then reposition and do the recursive call
+                printer.reset_line_to(n.position().lineno);
+                generating_assignment_from = &n;
+                emit( n, capture_intro );
+                generating_assignment_from = {};
+            }
+
+            //  If this was a constructor and we want also want to emit
+            //  it as an assignment operator, do it via a recursive call
+            if (need_to_generate_move)
+            {
+                //  Reset the 'emitted' flags
+                for (auto& statement : n.get_initializer_statements()) {
+                    statement->emitted = false;
+                }
+
+                //  Then reposition and do the recursive call
+                printer.reset_line_to(n.position().lineno);
+                generating_move_from = &n;
+                emit( n, capture_intro );
+                generating_move_from = {};
+            }
+
+            //  If this is ++ or --, emit the Cpp1 postfix version via a recursive call
+            if (need_to_generate_postfix_inc_dec)
+            {
+                //  Reset the 'emitted' flags
+                for (auto& statement : n.get_initializer_statements()) {
+                    statement->emitted = false;
+                }
+
+                //  Then reposition and do the recursive call
+                printer.reset_line_to(n.position().lineno);
+                generating_postfix_inc_dec_from = &n;
+                emit( n, capture_intro );
+                generating_postfix_inc_dec_from = {};
+            }
+        }
+
+        //  Object with optional initializer
+        else if (
+            n.is_object()
+            && (
+                (
+                    n.parent_is_namespace()
+                    && printer.get_phase() >= printer.phase1_type_defs_func_decls
+                    )
+                ||
+                (
+                    n.parent_is_type()
+                    && printer.get_phase() == printer.phase1_type_defs_func_decls
+                    )
+                ||
+                (
+                    n.parent_is_function()
+                    && printer.get_phase() == printer.phase2_func_defs
+                    )
+                ||
+                (
+                    n.is_inside_global_unnamed_function()
+                    && printer.get_phase() == printer.phase1_type_defs_func_decls
+                    )
+                )
+            )
+        {
+            auto& type = std::get<declaration_node::an_object>(n.type);
+            if (
+                printer.get_phase() == printer.phase2_func_defs
+                && type->is_concept()
+               )
+            {
+                return;
+            }
+
+            emit_requires_clause();
+
+            if (
+                printer.get_phase() != printer.phase2_func_defs
+                && n.parent_is_namespace()
+                && !type->is_concept()
+                )
+            {
+                printer.print_cpp2( "extern ", n.position() );
+            }
+
+            //  Emit "auto" for deduced types (of course)
+            if (type->is_wildcard()) {
+                assert(n.initializer);
+                emit( *type, n.position() );
+            }
+            //  Otherwise, emit the type
+            else {
+                //  If there isn't an initializer, use cpp2::deferred_init<T>
+                if (!n.initializer) {
+                    if (n.parent_is_function()) {
+                        printer.print_cpp2( "cpp2::deferred_init<", n.position() );
+                    }
+                    else if (!n.parent_is_type()) {
+                        errors.emplace_back(
+                            n.position(),
+                            "a namespace-scope object must have an initializer"
+                        );
+                        return;
+                    }
+                }
+                printer.preempt_position_push(n.position());
+                emit( *type );
+                printer.preempt_position_pop();
+                //  one pointer is enough for now, pointer-to-function fun can be later
+                if (
+                    !n.initializer
+                    && n.parent_is_function()
+                    )
+                {
+                    printer.print_cpp2( ">", n.position() );
+                }
+            }
+
+            printer.print_cpp2( " ", n.position());
+            assert(n.identifier);
+
+            //  If this is anonymous object (named "_"), generate a unique name
+            if (n.has_name("_")) {
+                if (n.has_wildcard_type()) {
+                    errors.emplace_back(
+                        n.identifier->position(),
+                        "an object can have an anonymous name or an anonymous type, but not both at the same type (rationale: if '_ := f();' were allowed to keep the returned object alive, that syntax would be dangerously close to '_ = f();' to discard the returned object, and such importantly opposite meanings deserve more than a one-character typo distance; and explicit discarding gets the nice syntax because it's likely more common)"
+                    );
+                    return;
+                }
+
+                printer.print_cpp2(
+                    "auto_" + labelized_position(n.identifier->get_token()),
+                    n.identifier->position()
+                );
+            }
+            else {
+                emit(*n.identifier);
+            }
+
+            if (
+                n.parent_is_namespace()
+                && printer.get_phase() != printer.phase2_func_defs
+                && !type->is_concept()
+                )
+            {
+                printer.print_cpp2( ";", n.position());
+                return;
+            }
+
+            //  If there's an initializer, emit it
+            if (n.initializer)
+            {
+                printer.add_pad_in_this_line(-100);
+                if (type->is_concept()) {
+                    printer.print_cpp2( " = ", n.position() );
+                } else {
+                    printer.print_cpp2( " {", n.position() );
+                }
+
+                push_need_expression_list_parens(false);
+                assert( n.initializer );
+                emit( *n.initializer, false );
+                pop_need_expression_list_parens();
+
+                if (!type->is_concept()) {
+                    printer.print_cpp2( "}", n.position() );
+                }
+            }
+
+            printer.print_cpp2( "; ", n.position() );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  print_errors
+    //
+    auto print_errors()
+        -> void
+    {
+        if (!errors.empty()) {
+            //  Delete the output file
+            printer.abandon();
+        }
+
+        error_entry const* prev                  = {};
+        bool               print_fallback_errors = true; // true until we find a non-fallback message
+
+        for (auto&& error : errors)
+        {
+            //  Only print fallback error messages if we
+            //  haven't found a better (non-fallback) one yet
+            if (!error.fallback) {
+                print_fallback_errors = false;
+            }
+            if (error.fallback && !print_fallback_errors) {
+                continue;
+            }
+
+            //  Suppress adjacent duplicates (e.g., can arise when we
+            //  reenter operator= to emit it as an assignment operator)
+            if (
+                !prev
+                || error != *prev
+                )
+            {
+                error.print(std::cerr, strip_path(sourcefile));
+            }
+            prev = &error;
+        }
+
+        if (violates_lifetime_safety) {
+            std::cerr << "  ==> program violates lifetime safety guarantee - see previous errors\n";
+        }
+        if (violates_bounds_safety) {
+            std::cerr << "  ==> program violates bounds safety guarantee - see previous errors\n";
+        }
+        if (violates_initialization_safety) {
+            std::cerr << "  ==> program violates initialization safety guarantee - see previous errors\n";
+        }
+    }
+
+    auto had_no_errors()
+        -> bool
+    {
+        return errors.empty();
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  debug_print
+    //
+    auto debug_print()
+        -> void
+    {
+        //  Only create debug output files if we managed to load the source file.
+        //
+        if (source_loaded)
+        {
+            auto out_source  = std::ofstream{ sourcefile+"-source"  };
+            source.debug_print( out_source );
+
+            auto out_tokens  = std::ofstream{ sourcefile+"-tokens"  };
+            tokens.debug_print( out_tokens );
+
+            auto out_parse   = std::ofstream{ sourcefile+"-parse"   };
+            parser.debug_print( out_parse );
+
+            auto out_symbols = std::ofstream{ sourcefile+"-symbols" };
+            sema.debug_print  ( out_symbols );
+        }
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  has_cpp1: pass through
+    //
+    auto has_cpp1() const
+        -> bool
+    {
+        return source.has_cpp1();
+    }
+
+
+    //-----------------------------------------------------------------------
+    //  has_cpp2: pass through
+    //
+    auto has_cpp2() const
+        -> bool
+    {
+        return source.has_cpp2();
+    }
+};
+
+}
+
+
+#endif