Changes in / [67130fe:c6a1e8a]

Location:

src

Files:

• AST/Bitfield.hpp (modified) (2 diffs)
• AST/Chain.hpp (added)
• AST/Convert.cpp (modified) (3 diffs)
• AST/Decl.hpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Node.hpp (modified) (4 diffs)
• AST/Pass.hpp (modified) (4 diffs)
• AST/Pass.impl.hpp (modified) (61 diffs)
• AST/Pass.proto.hpp (modified) (9 diffs)
• AST/Print.hpp (modified) (1 diff)
• AST/SymbolTable.hpp (modified) (2 diffs)
• AST/porting.md (modified) (2 diffs)
• Common/Indenter.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• Makefile.in (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/Candidate.cpp (added)
• ResolvExpr/Candidate.hpp (added)
• ResolvExpr/CandidateFinder.cpp (added)
• ResolvExpr/CandidateFinder.hpp (added)
• ResolvExpr/ResolveAssertions.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (29 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (1 diff)
• SynTree/DeclReplacer.cc (modified) (6 diffs)
• SynTree/DeclReplacer.h (modified) (1 diff)
• main.cc (modified) (2 diffs)

src/AST/Bitfield.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Thu May 9 10:00:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 5 10:00:00 2019
+// Update Count     : 2
 //
 
 #pragma once
 
-#include <strings.h>  // for ffs
+#include <strings.h>   // for ffs
+#include <type_traits> // for is_unsigned
 
 /// Make a type a bitfield.
@@ -24 +25 @@
 template<typename T>
 struct bitfield : public T {
-        static_assert(sizeof(T) == sizeof(unsigned int), "Type has incorrect size");
         using T::val;
         using val_t = decltype(val);
+        static_assert(sizeof(T) == sizeof(unsigned int), "Type has incorrect size");
+        static_assert(std::is_unsigned<val_t>::value, "Bitfield val field is not unsigned.");
 
         constexpr bitfield() : T( 0 ) {}

src/AST/Convert.cpp

@@ -749 +749 @@
                         break;
                 case ast::ConstantExpr::String:
-                        rslt = new ConstantExpr{Constant::from_string( node->rep )};
+                        rslt = new ConstantExpr{Constant{
+                                get<Type>().accept1( node->result ),
+                                node->rep,
+                                (long long unsigned int)0
+                        }};
                         break;
                 }
@@ -2150 +2154 @@
                                 GET_ACCEPT_1(result, Type),
                                 old->constant.get_value(),
-                                (unsigned long long) old->intValue()
+                                (unsigned long long) old->intValue(),
+                                ast::ConstantExpr::Kind::Integer
                         );
                 } else if (isFloatlikeConstantType(old->result)) {
@@ -2160 +2165 @@
                         );
                 } else if (isStringlikeConstantType(old->result)) {
-                        rslt = ast::ConstantExpr::from_string(
-                                old->location,
-                                old->constant.get_value()
+                        rslt = new ast::ConstantExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                old->constant.get_value(),
+                                0,
+                                ast::ConstantExpr::Kind::String
                         );
                 }

src/AST/Decl.hpp

@@ -103 +103 @@
 
         ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, 
-                Init * init = nullptr, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, 
-                Expr * bitWd = nullptr, std::vector< ptr<Attribute> > && attrs = {}, 
-                Function::Specs fs = {} )
+                const Init * init = nullptr, Storage::Classes storage = {}, 
+                Linkage::Spec linkage = Linkage::C, const Expr * bitWd = nullptr, 
+                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
           init( init ), bitfieldWidth( bitWd ) {}

src/AST/Node.cpp

@@ -34 +34 @@
 template< typename node_t, enum ast::Node::ref_type ref_t >
 void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
 
 template< typename node_t, enum ast::Node::ref_type ref_t >

src/AST/Node.hpp

@@ -46 +46 @@
         };
 
+        bool unique() const { return strong_count == 1; }
+
 private:
         /// Make a copy of this node; should be overridden in subclass with more precise return type
@@ -56 +58 @@
         mutable size_t strong_count = 0;
         mutable size_t weak_count = 0;
+        mutable bool was_ever_strong = false;
 
         void increment(ref_type ref) const {
                 switch (ref) {
-                        case ref_type::strong: strong_count++; break;
+                        case ref_type::strong: strong_count++; was_ever_strong = true; break;
                         case ref_type::weak  : weak_count  ++; break;
                 }
@@ -176 +179 @@
         }
 
-        const node_t * get() const { return  node; }
-        const node_t * operator->() const { return  node; }
-        const node_t & operator* () const { return *node; }
-        explicit operator bool() const { return node; }
-        operator const node_t * () const { return node; }
+        const node_t * get() const { _check(); return  node; }
+        const node_t * operator->() const { _check(); return  node; }
+        const node_t & operator* () const { _check(); return *node; }
+        explicit operator bool() const { _check(); return node; }
+        operator const node_t * () const { _check(); return node; }
 
         /// wrapper for convenient access to dynamic_cast
         template<typename o_node_t>
-        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
 
         /// wrapper for convenient access to strict_dynamic_cast
@@ -208 +211 @@
         void _inc( const node_t * other );
         void _dec( const node_t * other );
+        void _check() const;
 
 protected:

src/AST/Pass.hpp

@@ -33 +33 @@
 #include "AST/Visitor.hpp"
 
-#include "SymTab/Indexer.h"
+#include "AST/SymbolTable.hpp"
 
 // Private prelude header, needed for some of the magic tricks this class pulls off
@@ -61 +61 @@
 //                          postvisit/postmutate teminates.
 // | WithVisitorRef       - provides an pointer to the templated visitor wrapper
-// | WithIndexer          - provides indexer functionality (i.e. up-to-date symbol table)
+// | WithSymbolTable      - provides symbol table functionality
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
@@ -206 +206 @@
 
 private:
-        /// Internal RAII guard for indexer features
-        struct guard_indexer {
-                guard_indexer( Pass<pass_t> & pass ): pass( pass ) { __pass::indexer::enter(pass, 0); }
-                ~guard_indexer()                                   { __pass::indexer::leave(pass, 0); }
+        /// Internal RAII guard for symbol table features
+        struct guard_symtab {
+                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
                 Pass<pass_t> & pass;
         };
@@ -294 +294 @@
 };
 
-/// Use when the templated visitor should update the indexer
-struct WithIndexer {
-        SymTab::Indexer indexer;
+/// Use when the templated visitor should update the symbol table
+struct WithSymbolTable {
+        SymbolTable symtab;
 };
 }

src/AST/Pass.impl.hpp

@@ -398 +398 @@
         VISIT(
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &ObjectDecl::type );
                 }
@@ -406 +406 @@
         )
 
-        __pass::indexer::addId( pass, 0, node );
+        __pass::symtab::addId( pass, 0, node );
 
         VISIT_END( DeclWithType, node );
@@ -417 +417 @@
         VISIT_START( node );
 
-        __pass::indexer::addId( pass, 0, node );
+        __pass::symtab::addId( pass, 0, node );
 
         VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
         {
                 // with clause introduces a level of scope (for the with expression members).
-                // with clause exprs are added to the indexer before parameters so that parameters
+                // with clause exprs are added to the symbol table before parameters so that parameters
                 // shadow with exprs and not the other way around.
-                guard_indexer guard { *this };
-                __pass::indexer::addWith( pass, 0, node->withExprs, node );
+                guard_symtab guard { *this };
+                __pass::symtab::addWith( pass, 0, node->withExprs, node );
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
                         static ast::ObjectDecl func(
@@ -436 +436 @@
                                 )
                         );
-                        __pass::indexer::addId( pass, 0, &func );
+                        __pass::symtab::addId( pass, 0, &func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -460 +460 @@
         // make up a forward declaration and add it before processing the members
         // needs to be on the heap because addStruct saves the pointer
-        __pass::indexer::addStructFwd( pass, 0, node );
-
-        VISIT({
-                guard_indexer guard { * this };
+        __pass::symtab::addStructFwd( pass, 0, node );
+
+        VISIT({
+                guard_symtab guard { * this };
                 maybe_accept( node, &StructDecl::params  );
                 maybe_accept( node, &StructDecl::members );
@@ -469 +469 @@
 
         // this addition replaces the forward declaration
-        __pass::indexer::addStruct( pass, 0, node );
+        __pass::symtab::addStruct( pass, 0, node );
 
         VISIT_END( Decl, node );
@@ -481 +481 @@
 
         // make up a forward declaration and add it before processing the members
-        __pass::indexer::addUnionFwd( pass, 0, node );
-
-        VISIT({
-                guard_indexer guard { * this };
+        __pass::symtab::addUnionFwd( pass, 0, node );
+
+        VISIT({
+                guard_symtab guard { * this };
                 maybe_accept( node, &UnionDecl::params  );
                 maybe_accept( node, &UnionDecl::members );
         })
 
-        __pass::indexer::addUnion( pass, 0, node );
+        __pass::symtab::addUnion( pass, 0, node );
 
         VISIT_END( Decl, node );
@@ -500 +500 @@
         VISIT_START( node );
 
-        __pass::indexer::addEnum( pass, 0, node );
+        __pass::symtab::addEnum( pass, 0, node );
 
         VISIT(
@@ -518 +518 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &TraitDecl::params  );
                 maybe_accept( node, &TraitDecl::members );
         })
 
-        __pass::indexer::addTrait( pass, 0, node );
+        __pass::symtab::addTrait( pass, 0, node );
 
         VISIT_END( Decl, node );
@@ -535 +535 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &TypeDecl::params );
                 maybe_accept( node, &TypeDecl::base   );
@@ -543 +543 @@
         // note that assertions come after the type is added to the symtab, since they are not part of the type proper
         // and may depend on the type itself
-        __pass::indexer::addType( pass, 0, node );
+        __pass::symtab::addType( pass, 0, node );
 
         VISIT(
@@ -549 +549 @@
 
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &TypeDecl::init );
                 }
@@ -564 +564 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &TypedefDecl::params );
                 maybe_accept( node, &TypedefDecl::base   );
         })
 
-        __pass::indexer::addType( pass, 0, node );
+        __pass::symtab::addType( pass, 0, node );
 
         VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
@@ -611 +611 @@
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::indexer::enter(pass, 0);
+                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
                 }, [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::indexer::leave(pass, 0);
+                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -669 +669 @@
         VISIT({
                 // if statements introduce a level of scope (for the initialization)
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
@@ -687 +687 @@
         VISIT({
                 // while statements introduce a level of scope (for the initialization)
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
@@ -704 +704 @@
         VISIT({
                 // for statements introduce a level of scope (for the initialization)
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
@@ -800 +800 @@
         VISIT({
                 // catch statements introduce a level of scope (for the caught exception)
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
@@ -901 +901 @@
                 {
                         // catch statements introduce a level of scope (for the caught exception)
-                        guard_indexer guard { *this };
-                        __pass::indexer::addWith( pass, 0, node->exprs, node );
+                        guard_symtab guard { *this };
+                        __pass::symtab::addWith( pass, 0, node->exprs, node );
                         maybe_accept( node, &WithStmt::stmt );
                 }
@@ -953 +953 @@
         VISIT(
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &ApplicationExpr::result );
                 }
@@ -971 +971 @@
         VISIT(
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UntypedExpr::result );
                 }
@@ -988 +988 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &NameExpr::result );
         })
@@ -1002 +1002 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &CastExpr::result );
                 }
@@ -1018 +1018 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &KeywordCastExpr::result );
                 }
@@ -1034 +1034 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &VirtualCastExpr::result );
                 }
@@ -1050 +1050 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &AddressExpr::result );
                 }
@@ -1066 +1066 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &LabelAddressExpr::result );
         })
@@ -1080 +1080 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UntypedMemberExpr::result );
                 }
@@ -1097 +1097 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &MemberExpr::result );
                 }
@@ -1113 +1113 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &VariableExpr::result );
         })
@@ -1127 +1127 @@
 
         VISIT({
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &ConstantExpr::result );
         })
@@ -1141 +1141 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &SizeofExpr::result );
                 }
@@ -1161 +1161 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &AlignofExpr::result );
                 }
@@ -1181 +1181 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UntypedOffsetofExpr::result );
                 }
@@ -1197 +1197 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &OffsetofExpr::result );
                 }
@@ -1213 +1213 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &OffsetPackExpr::result );
                 }
@@ -1229 +1229 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &LogicalExpr::result );
                 }
@@ -1246 +1246 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &ConditionalExpr::result );
                 }
@@ -1264 +1264 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &CommaExpr::result );
                 }
@@ -1281 +1281 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &TypeExpr::result );
                 }
@@ -1297 +1297 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &AsmExpr::result );
                 }
@@ -1315 +1315 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &ImplicitCopyCtorExpr::result );
                 }
@@ -1331 +1331 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &ConstructorExpr::result );
                 }
@@ -1347 +1347 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &CompoundLiteralExpr::result );
                 }
@@ -1363 +1363 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &RangeExpr::result );
                 }
@@ -1380 +1380 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UntypedTupleExpr::result );
                 }
@@ -1396 +1396 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &TupleExpr::result );
                 }
@@ -1412 +1412 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &TupleIndexExpr::result );
                 }
@@ -1428 +1428 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &TupleAssignExpr::result );
                 }
@@ -1454 +1454 @@
 
                 {
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &StmtExpr::result );
                 }
@@ -1472 +1472 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UniqueExpr::result );
                 }
@@ -1488 +1488 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &UntypedInitExpr::result );
                 }
@@ -1505 +1505 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &InitExpr::result );
                 }
@@ -1522 +1522 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &DeletedExpr::result );
                 }
@@ -1539 +1539 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &DefaultArgExpr::result );
                 }
@@ -1555 +1555 @@
 
         VISIT({
-                        guard_indexer guard { *this };
+                        guard_symtab guard { *this };
                         maybe_accept( node, &GenericExpr::result );
                 }
@@ -1566 +1566 @@
                         const Type * type = nullptr;
                         if( assoc.type ) {
-                                guard_indexer guard { *this };
+                                guard_symtab guard { *this };
                                 type = assoc.type->accept( *this );
                                 if( type != assoc.type ) mutated = true;
@@ -1682 +1682 @@
         VISIT_START( node );
 
-        __pass::indexer::addStruct( pass, 0, node->name );
-
-        VISIT({
-                guard_indexer guard { *this };
+        __pass::symtab::addStruct( pass, 0, node->name );
+
+        VISIT({
+                guard_symtab guard { *this };
                 maybe_accept( node, &StructInstType::forall );
                 maybe_accept( node, &StructInstType::params );
@@ -1699 +1699 @@
         VISIT_START( node );
 
-        __pass::indexer::addStruct( pass, 0, node->name );
+        __pass::symtab::addStruct( pass, 0, node->name );
 
         {
-                guard_indexer guard { *this };
+                guard_symtab guard { *this };
                 maybe_accept( node, &UnionInstType::forall );
                 maybe_accept( node, &UnionInstType::params );
@@ -1893 +1893 @@
                         std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
                         for ( const auto & p : node->typeEnv ) {
-                                guard_indexer guard { *this };
+                                guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
                                 if (new_node != p.second) mutated = false;
@@ -1909 +1909 @@
                         std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
                         for ( const auto & p : node->varEnv ) {
-                                guard_indexer guard { *this };
+                                guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
                                 if (new_node != p.second) mutated = false;

src/AST/Pass.proto.hpp

@@ -265 +265 @@
         };
 
-        // Finally certain pass desire an up to date indexer automatically
-        // detect the presence of a member name indexer and call all the members appropriately
-        namespace indexer {
+        // Finally certain pass desire an up to date symbol table automatically
+        // detect the presence of a member name `symtab` and call all the members appropriately
+        namespace symtab {
                 // Some simple scoping rules
                 template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.indexer.enterScope(), void() ) {
-                        pass.indexer.enterScope();
+                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
+                        pass.symtab.enterScope();
                 }
 
@@ -278 +278 @@
 
                 template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.indexer.leaveScope(), void() ) {
-                        pass.indexer.leaveScope();
+                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
+                        pass.symtab.leaveScope();
                 }
 
@@ -285 +285 @@
                 static inline auto leave( pass_t &, long ) {}
 
-                // The indexer has 2 kind of functions mostly, 1 argument and 2 arguments
+                // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
                 // Create macro to condense these common patterns
-                #define INDEXER_FUNC1( func, type ) \
+                #define SYMTAB_FUNC1( func, type ) \
                 template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.indexer.func( arg ), void() ) {\
-                        pass.indexer.func( arg ); \
+                static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\
+                        pass.symtab.func( arg ); \
                 } \
                 \
@@ -296 +296 @@
                 static inline void func( pass_t &, long, type ) {}
 
-                #define INDEXER_FUNC2( func, type1, type2 ) \
+                #define SYMTAB_FUNC2( func, type1, type2 ) \
                 template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.indexer.func( arg1, arg2 ), void () ) {\
-                        pass.indexer.func( arg1, arg2 ); \
+                static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\
+                        pass.symtab.func( arg1, arg2 ); \
                 } \
                         \
@@ -305 +305 @@
                 static inline void func( pass_t &, long, type1, type2 ) {}
 
-                INDEXER_FUNC1( addId     , const DeclWithType *  );
-                INDEXER_FUNC1( addType   , const NamedTypeDecl * );
-                INDEXER_FUNC1( addStruct , const StructDecl *    );
-                INDEXER_FUNC1( addEnum   , const EnumDecl *      );
-                INDEXER_FUNC1( addUnion  , const UnionDecl *     );
-                INDEXER_FUNC1( addTrait  , const TraitDecl *     );
-                INDEXER_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
+                SYMTAB_FUNC1( addId     , const DeclWithType *  );
+                SYMTAB_FUNC1( addType   , const NamedTypeDecl * );
+                SYMTAB_FUNC1( addStruct , const StructDecl *    );
+                SYMTAB_FUNC1( addEnum   , const EnumDecl *      );
+                SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
+                SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
+                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
 
                 // A few extra functions have more complicated behaviour, they are hand written
                 template<typename pass_t>
-                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) {
+                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) {
                         ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.indexer.addStruct( fwd );
+                        pass.symtab.addStruct( fwd );
                 }
 
@@ -325 +325 @@
 
                 template<typename pass_t>
-                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) {
+                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) {
                         UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.indexer.addUnion( fwd );
+                        pass.symtab.addUnion( fwd );
                 }
 
@@ -335 +335 @@
 
                 template<typename pass_t>
-                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) {
-                        if ( ! pass.indexer.lookupStruct( str ) ) {
-                                pass.indexer.addStruct( str );
+                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) {
+                        if ( ! pass.symtab.lookupStruct( str ) ) {
+                                pass.symtab.addStruct( str );
                         }
                 }
@@ -345 +345 @@
 
                 template<typename pass_t>
-                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) {
-                        if ( ! pass.indexer.lookupUnion( str ) ) {
-                                pass.indexer.addUnion( str );
+                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) {
+                        if ( ! pass.symtab.lookupUnion( str ) ) {
+                                pass.symtab.addUnion( str );
                         }
                 }
@@ -354 +354 @@
                 static inline void addUnion( pass_t &, long, const std::string & ) {}
 
-                #undef INDEXER_FUNC1
-                #undef INDEXER_FUNC2
+                #undef SYMTAB_FUNC1
+                #undef SYMTAB_FUNC2
         };
 };

src/AST/Print.hpp

@@ -29 +29 @@
 void print( std::ostream & os, const ast::Node * node, Indenter indent = {} );
 
-/// Wrap any standard format printer (matching above) with integer Indenter constructor
-template<typename T>
-inline void print( std::ostream & os, T && x, unsigned int indent ) {
-    print( os, std::forward<T>(x), Indenter{ Indenter::tabsize, indent });
-}
-
 /// Print a declaration in its short form
 void printShort( std::ostream & os, const ast::Decl * node, Indenter indent = {} );
 
 inline void printShort( std::ostream & os, const ast::Decl * node, unsigned int indent ) {
-    printShort( os, node, Indenter{ Indenter::tabsize, indent } );
+    printShort( os, node, Indenter{ indent } );
 }
 

src/AST/SymbolTable.hpp

@@ -85 +85 @@
 
 public:
-        explicit SymbolTable();
+        SymbolTable();
         ~SymbolTable();
 
@@ -123 +123 @@
         void addType( const NamedTypeDecl * decl );
         /// Adds a struct declaration to the symbol table by name
-        void addStruct( const std::string &id );
+        void addStruct( const std::string & id );
         /// Adds a struct declaration to the symbol table
         void addStruct( const StructDecl * decl );
         /// Adds an enum declaration to the symbol table
-        void addEnum( const EnumDecl *decl );
+        void addEnum( const EnumDecl * decl );
         /// Adds a union declaration to the symbol table by name
-        void addUnion( const std::string &id );
+        void addUnion( const std::string & id );
         /// Adds a union declaration to the symbol table
         void addUnion( const UnionDecl * decl );

src/AST/porting.md

@@ -109 +109 @@
     * `SymTab::Indexer` => `ast::SymbolTable`
     * `SymTab/Indexer.{h,cc}` => `AST/SymbolTable.{hpp,cpp}`
-    * **TODO** `WithIndexer` => `WithSymbolTable`
+    * `WithIndexer` => `WithSymbolTable`
       * `indexer` => `symTab`
     * `IdData::deleteStmt` => `IdData::deleter`
     * `lookupId()` now returns a vector rather than an out-param list
-    * To avoid name collisions:
-      * `SymTab::Mangler` => `Mangle`
+  * To avoid name collisions:
+    * `SymTab::Mangler` => `Mangle`
   * `ResolvExpr::TypeEnvironment` => `ast::TypeEnvironment`
     * in `AST/TypeEnvironment.hpp`
@@ -295 +295 @@
 * changed `WidenMode widenMode` => `WidenMode widen`
 
+`Alternative` => `Candidate`
+* `openVars` => `open`
+
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes
 

src/Common/Indenter.h

@@ -18 +18 @@
 
 struct Indenter {
-        static unsigned tabsize;
+        static unsigned tabsize;  ///< default number of spaces in one level of indentation
 
-        Indenter( unsigned int amt = tabsize, unsigned int indent = 0 ) : amt( amt ), indent( indent ) {}
-        unsigned int amt;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
-        unsigned int indent;
+        unsigned int indent;      ///< number of spaces to indent
+        unsigned int amt;         ///< spaces in one level of indentation
 
+        Indenter( unsigned int indent = 0, unsigned int amt = tabsize ) 
+        : indent( indent*amt ), amt( amt ) {}
+        
         Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
         Indenter & operator-=(int nlevels) { indent -= amt*nlevels; return *this; }

src/InitTweak/FixInit.cc

@@ -715 +715 @@
                                 stmtsToAddBefore.push_back( new DeclStmt( ret ) );
 
-                                if(!stmtExpr->resultExpr) {
-                                        SemanticError(stmtExpr, "Statment-Expression should have a resulting expression");
-                                }
+                                assertf(
+                                        stmtExpr->resultExpr,
+                                        "Statement-Expression should have a resulting expression at %s:%d",
+                                        stmtExpr->location.filename.c_str(),
+                                        stmtExpr->location.first_line
+                                );
+
                                 ExprStmt * last = stmtExpr->resultExpr;
                                 try {
                                         last->expr = makeCtorDtor( "?{}", ret, last->expr );
                                 } catch(...) {
-                                        std::cerr << "=======================" << std::endl;
-                                        std::cerr << "ERROR, can't resolve" << std::endl;
-                                        ret->print(std::cerr);
-                                        std::cerr << std::endl << "---" << std::endl;
-                                        last->expr->print(std::cerr);
+                                        std::cerr << "*CFA internal error: ";
+                                        std::cerr << "can't resolve implicit constructor";
+                                        std::cerr << " at " << stmtExpr->location.filename;
+                                        std::cerr << ":" << stmtExpr->location.first_line << std::endl;
 
                                         abort();

src/Makefile.in

@@ -189 +189 @@
         ResolvExpr/Alternative.$(OBJEXT) \
         ResolvExpr/AlternativeFinder.$(OBJEXT) \
+        ResolvExpr/Candidate.$(OBJEXT) \
+        ResolvExpr/CandidateFinder.$(OBJEXT) \
         ResolvExpr/CastCost.$(OBJEXT) ResolvExpr/CommonType.$(OBJEXT) \
         ResolvExpr/ConversionCost.$(OBJEXT) \
@@ -622 +624 @@
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/Candidate.cpp \
+      ResolvExpr/CandidateFinder.cpp \
       ResolvExpr/CastCost.cc \
       ResolvExpr/CommonType.cc \
@@ -872 +876 @@
 ResolvExpr/AlternativeFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/Candidate.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/CandidateFinder.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/CastCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
@@ -1254 +1262 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/AlternativeFinder.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/AlternativePrinter.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/Candidate.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/CandidateFinder.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/CastCost.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/CommonType.Po@am__quote@

src/ResolvExpr/AlternativeFinder.cc

@@ -136 +136 @@
 
         void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
-                Indenter indent = { Indenter::tabsize, indentAmt };
+                Indenter indent = { indentAmt };
                 for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
                         i->print( os, indent );

src/ResolvExpr/ResolveAssertions.cc

@@ -365 +365 @@
                                         // fail early if any assertion is not resolvable
                                         if ( ! resolveAssertion( assn, resn ) ) {
-                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                Indenter tabs{ 3 };
                                                 std::ostringstream ss;
                                                 ss << tabs << "Unsatisfiable alternative:\n";
@@ -391 +391 @@
                                         // fail early if no mutually-compatible assertion satisfaction
                                         if ( compatible.empty() ) {
-                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                Indenter tabs{ 3 };
                                                 std::ostringstream ss;
                                                 ss << tabs << "Unsatisfiable alternative:\n";

src/ResolvExpr/Resolver.cc

@@ -21 +21 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "Candidate.hpp"
+#include "CandidateFinder.hpp"
 #include "CurrentObject.h"               // for CurrentObject
 #include "RenameVars.h"                  // for RenameVars, global_renamer
@@ -27 +29 @@
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "AST/Chain.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Init.hpp"
 #include "AST/Pass.hpp"
+#include "AST/Print.hpp"
 #include "AST/SymbolTable.hpp"
 #include "Common/PassVisitor.h"          // for PassVisitor
@@ -113 +119 @@
 
         namespace {
-                struct DeleteFinder : public WithShortCircuiting        {
+                struct DeleteFinder_old : public WithShortCircuiting    {
                         DeletedExpr * delExpr = nullptr;
                         void previsit( DeletedExpr * expr ) {
@@ -127 +133 @@
 
         DeletedExpr * findDeletedExpr( Expression * expr ) {
-                PassVisitor<DeleteFinder> finder;
+                PassVisitor<DeleteFinder_old> finder;
                 expr->accept( finder );
                 return finder.pass.delExpr;
@@ -133 +139 @@
 
         namespace {
-                struct StripCasts {
+                struct StripCasts_old {
                         Expression * postmutate( CastExpr * castExpr ) {
                                 if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
@@ -146 +152 @@
 
                         static void strip( Expression *& expr ) {
-                                PassVisitor<StripCasts> stripper;
+                                PassVisitor<StripCasts_old> stripper;
                                 expr = expr->acceptMutator( stripper );
                         }
@@ -154 +160 @@
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
-                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
+                        StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
                 }
 
@@ -405 +411 @@
 
         void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
+                // class-variable initContext is changed multiple time because the LHS is analysed twice.
+                // The second analysis changes initContext because of a function type can contain object
+                // declarations in the return and parameter types. So each value of initContext is
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -445 +451 @@
 
         void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I
@@ -937 +943 @@
         ///////////////////////////////////////////////////////////////////////////
 
-        class Resolver_new final 
-        : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef<Resolver_new>, 
-          public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> {
-                  
-        public: 
+        namespace {
+                /// Finds deleted expressions in an expression tree
+                struct DeleteFinder_new final : public ast::WithShortCircuiting {
+                        const ast::DeletedExpr * delExpr = nullptr;
+
+                        void previsit( const ast::DeletedExpr * expr ) {
+                                if ( delExpr ) { visit_children = false; }
+                                else { delExpr = expr; }
+                        }
+
+                        void previsit( const ast::Expr * ) {
+                                if ( delExpr ) { visit_children = false; }
+                        }
+                };
+
+                /// Check if this expression is or includes a deleted expression
+                const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
+                        ast::Pass<DeleteFinder_new> finder;
+                        expr->accept( finder );
+                        return finder.pass.delExpr;
+                }
+
+                /// Calls the CandidateFinder and finds the single best candidate
+                CandidateRef findUnfinishedKindExpression(
+                        const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, 
+                        std::function<bool(const Candidate &)> pred, ResolvMode mode = {}
+                ) {
+                        if ( ! untyped ) return nullptr;
+
+                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
+                        static unsigned recursion_level = 0;
+
+                        ++recursion_level;
+                        ast::TypeEnvironment env;
+                        CandidateFinder finder{ symtab, env };
+                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
+                        --recursion_level;
+
+                        // produce a filtered list of candidates
+                        CandidateList candidates;
+                        for ( auto & cand : finder.candidates ) {
+                                if ( pred( *cand ) ) { candidates.emplace_back( cand ); }
+                        }
+
+                        // produce invalid error if no candidates
+                        if ( candidates.empty() ) {
+                                SemanticError( untyped, 
+                                        toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""), 
+                                        "expression: ") );
+                        }
+
+                        // search for cheapest candidate
+                        CandidateList winners;
+                        bool seen_undeleted = false;
+                        for ( CandidateRef & cand : candidates ) {
+                                int c = winners.empty() ? -1 : cand->cost.compare( winners.front()->cost );
+
+                                if ( c > 0 ) continue;  // skip more expensive than winner
+
+                                if ( c < 0 ) {
+                                        // reset on new cheapest
+                                        seen_undeleted = ! findDeletedExpr( cand->expr );
+                                        winners.clear();
+                                } else /* if ( c == 0 ) */ {
+                                        if ( findDeletedExpr( cand->expr ) ) {
+                                                // skip deleted expression if already seen one equivalent-cost not
+                                                if ( seen_undeleted ) continue;
+                                        } else if ( ! seen_undeleted ) {
+                                                // replace list of equivalent-cost deleted expressions with one non-deleted
+                                                winners.clear();
+                                                seen_undeleted = true;
+                                        }
+                                }
+
+                                winners.emplace_back( std::move( cand ) );
+                        }
+
+                        // promote candidate.cvtCost to .cost
+                        for ( CandidateRef & cand : winners ) {
+                                cand->cost = cand->cvtCost;
+                        }
+
+                        // produce ambiguous errors, if applicable
+                        if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " 
+                                        << kind << (kind != "" ? " " : "") << "expression\n";
+                                ast::print( stream, untyped );
+                                stream << " Alternatives are:\n";
+                                print( stream, winners, 1 );
+                                SemanticError( untyped->location, stream.str() );
+                        }
+
+                        // single selected choice
+                        CandidateRef & choice = winners.front();
+
+                        // fail on only expression deleted
+                        if ( ! seen_undeleted ) {
+                                SemanticError( untyped->location, choice->expr.get(), "Unique best alternative "
+                                "includes deleted identifier in " );
+                        }
+
+                        return std::move( choice );
+                }
+
+                /// Strips extraneous casts out of an expression
+                struct StripCasts_new final {
+                        const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
+                                if ( 
+                                        castExpr->isGenerated 
+                                        && typesCompatible( castExpr->arg->result, castExpr->result ) 
+                                ) {
+                                        // generated cast is the same type as its argument, remove it after keeping env
+                                        ast::ptr<ast::Expr> arg = castExpr->arg;
+                                        arg.get_and_mutate()->env = castExpr->env;
+                                        return arg;
+                                }
+                                return castExpr;
+                        }
+
+                        static void strip( ast::ptr< ast::Expr > & expr ) {
+                                ast::Pass< StripCasts_new > stripper;
+                                expr = expr->accept( stripper );
+                        }
+                };
+
+                /// Establish post-resolver invariants for expressions
+                void finishExpr( 
+                        ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env, 
+                        const ast::TypeSubstitution * oldenv = nullptr
+                ) {
+                        // set up new type substitution for expression
+                        ast::ptr< ast::TypeSubstitution > newenv = 
+                                 oldenv ? oldenv : new ast::TypeSubstitution{};
+                        env.writeToSubstitution( *newenv.get_and_mutate() );
+                        expr.get_and_mutate()->env = std::move( newenv );
+                        // remove unncecessary casts
+                        StripCasts_new::strip( expr );
+                }
+                
+                /// resolve `untyped` to the expression whose candidate satisfies `pred` with the 
+                /// lowest cost, returning the resolved version
+                ast::ptr< ast::Expr > findKindExpression(
+                        const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, 
+                        std::function<bool(const Candidate &)> pred, ResolvMode mode = {}
+                ) {
+                        if ( ! untyped ) return {};
+                        CandidateRef choice = 
+                                findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
+                        finishExpr( choice->expr, choice->env, untyped->env );
+                        return std::move( choice->expr );
+                }
+
+                /// Predicate for "Candidate has integral type"
+                bool hasIntegralType( const Candidate & i ) {
+                        const ast::Type * type = i.expr->result;
+                        
+                        if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
+                                return bt->isInteger();
+                        } else if ( 
+                                dynamic_cast< const ast::EnumInstType * >( type ) 
+                                || dynamic_cast< const ast::ZeroType * >( type )
+                                || dynamic_cast< const ast::OneType * >( type )
+                        ) {
+                                return true;
+                        } else return false;
+                }
+
+                /// Resolve `untyped` as an integral expression, returning the resolved version
+                ast::ptr< ast::Expr > findIntegralExpression( 
+                        const ast::Expr * untyped, const ast::SymbolTable & symtab 
+                ) {
+                        return findKindExpression( untyped, symtab, "condition", hasIntegralType );
+                }
+        }
+
+        class Resolver_new final
+        : public ast::WithSymbolTable, public ast::WithGuards,
+          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
+          public ast::WithStmtsToAdd<> {
+
+                ast::ptr< ast::Type > functionReturn = nullptr;
+                // ast::CurrentObject currentObject = nullptr;
+                bool inEnumDecl = false;
+
+        public:
                 Resolver_new() = default;
-                Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ }
-
-                void previsit( ast::FunctionDecl * functionDecl );
-                ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl );
-                void previsit( ast::ObjectDecl * objectDecl );
-                void previsit( ast::EnumDecl * enumDecl );
-                void previsit( ast::StaticAssertDecl * assertDecl );
-
-                void previsit( ast::ArrayType * at );
-                void previsit( ast::PointerType * pt );
-
-                void previsit( ast::ExprStmt * exprStmt );
-                void previsit( ast::AsmExpr * asmExpr );
-                void previsit( ast::AsmStmt * asmStmt );
-                void previsit( ast::IfStmt * ifStmt );
-                void previsit( ast::WhileStmt * whileStmt );
-                void previsit( ast::ForStmt * forStmt );
-                void previsit( ast::SwitchStmt * switchStmt );
-                void previsit( ast::CaseStmt * caseStmt );
-                void previsit( ast::BranchStmt * branchStmt );
-                void previsit( ast::ReturnStmt * returnStmt );
-                void previsit( ast::ThrowStmt * throwStmt );
-                void previsit( ast::CatchStmt * catchStmt );
-                void previsit( ast::WaitForStmt * stmt );
-
-                void previsit( ast::SingleInit * singleInit );
-                void previsit( ast::ListInit * listInit );
-                void previsit( ast::ConstructorInit * ctorInit );
+                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
+
+                void previsit( const ast::FunctionDecl * );
+                const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
+                void previsit( const ast::ObjectDecl * );
+                void previsit( const ast::EnumDecl * );
+                const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
+
+                void previsit( const ast::ArrayType * );
+                void previsit( const ast::PointerType * );
+
+                void previsit( const ast::ExprStmt * );
+                void previsit( const ast::AsmExpr * );
+                void previsit( const ast::AsmStmt * );
+                void previsit( const ast::IfStmt * );
+                void previsit( const ast::WhileStmt * );
+                void previsit( const ast::ForStmt * );
+                void previsit( const ast::SwitchStmt * );
+                void previsit( const ast::CaseStmt * );
+                void previsit( const ast::BranchStmt * );
+                void previsit( const ast::ReturnStmt * );
+                void previsit( const ast::ThrowStmt * );
+                void previsit( const ast::CatchStmt * );
+                void previsit( const ast::WaitForStmt * );
+
+                void previsit( const ast::SingleInit * );
+                void previsit( const ast::ListInit * );
+                void previsit( const ast::ConstructorInit * );
         };
 
@@ -978 +1165 @@
         }
 
-        void previsit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-        }
-
-        ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-                return nullptr;
-        }
-
-        void previsit( ast::ObjectDecl * objectDecl ) {
+        void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
+                GuardValue( functionReturn );
+                functionReturn = extractResultType( functionDecl->type );
+        }
+
+        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
+                // default value expressions have an environment which shouldn't be there and trips up
+                // later passes.
+                ast::ptr< ast::FunctionDecl > ret = functionDecl;
+                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
+                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
+
+                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
+                                if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
+                                        if ( init->value->env == nullptr ) continue;
+                                        // clone initializer minus the initializer environment
+                                        ast::chain_mutate( ret )
+                                                ( &ast::FunctionDecl::type )
+                                                        ( &ast::FunctionType::params )[i]
+                                                                ( &ast::ObjectDecl::init )
+                                                                        ( &ast::SingleInit::value )->env = nullptr;
+
+                                        assert( functionDecl != ret.get() || functionDecl->unique() );
+                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
+                                }
+                        }
+                }
+                return ret.get();
+        }
+
+        void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
                 #warning unimplemented; Resolver port in progress
                 (void)objectDecl;
@@ -997 +1201 @@
         }
 
-        void previsit( ast::EnumDecl * enumDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)enumDecl;
-                assert(false);
-        }
-
-        void previsit( ast::StaticAssertDecl * assertDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)assertDecl;
-                assert(false);
-        }
-
-        void previsit( ast::ArrayType * at ) {
+        void Resolver_new::previsit( const ast::EnumDecl * ) {
+                // in case we decide to allow nested enums
+                GuardValue( inEnumDecl );
+                inEnumDecl = false;
+        }
+
+        const ast::StaticAssertDecl * Resolver_new::previsit( 
+                const ast::StaticAssertDecl * assertDecl 
+        ) {
+                ast::ptr< ast::Expr > cond = findIntegralExpression( assertDecl->cond, symtab );
+                if ( cond == assertDecl->cond ) return assertDecl;
+                
+                ast::StaticAssertDecl * ret = mutate( assertDecl );
+                ret->cond = cond;
+                return ret;
+        }
+
+        void Resolver_new::previsit( const ast::ArrayType * at ) {
                 #warning unimplemented; Resolver port in progress
                 (void)at;
@@ -1015 +1224 @@
         }
 
-        void previsit( ast::PointerType * pt ) {
+        void Resolver_new::previsit( const ast::PointerType * pt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)pt;
@@ -1021 +1230 @@
         }
 
-        void previsit( ast::ExprStmt * exprStmt ) {
+        void Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)exprStmt;
@@ -1027 +1236 @@
         }
 
-        void previsit( ast::AsmExpr * asmExpr ) {
+        void Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
                 #warning unimplemented; Resolver port in progress
                 (void)asmExpr;
@@ -1033 +1242 @@
         }
 
-        void previsit( ast::AsmStmt * asmStmt ) {
+        void Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)asmStmt;
@@ -1039 +1248 @@
         }
 
-        void previsit( ast::IfStmt * ifStmt ) {
+        void Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)ifStmt;
@@ -1045 +1254 @@
         }
 
-        void previsit( ast::WhileStmt * whileStmt ) {
+        void Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)whileStmt;
@@ -1051 +1260 @@
         }
 
-        void previsit( ast::ForStmt * forStmt ) {
+        void Resolver_new::previsit( const ast::ForStmt * forStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)forStmt;
@@ -1057 +1266 @@
         }
 
-        void previsit( ast::SwitchStmt * switchStmt ) {
+        void Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)switchStmt;
@@ -1063 +1272 @@
         }
 
-        void previsit( ast::CaseStmt * caseStmt ) {
+        void Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)caseStmt;
@@ -1069 +1278 @@
         }
 
-        void previsit( ast::BranchStmt * branchStmt ) {
+        void Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)branchStmt;
@@ -1075 +1284 @@
         }
 
-        void previsit( ast::ReturnStmt * returnStmt ) {
+        void Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)returnStmt;
@@ -1081 +1290 @@
         }
 
-        void previsit( ast::ThrowStmt * throwStmt ) {
+        void Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)throwStmt;
@@ -1087 +1296 @@
         }
 
-        void previsit( ast::CatchStmt * catchStmt ) {
+        void Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)catchStmt;
@@ -1093 +1302 @@
         }
 
-        void previsit( ast::WaitForStmt * stmt ) {
+        void Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)stmt;
@@ -1099 +1308 @@
         }
 
-        void previsit( ast::SingleInit * singleInit ) {
+        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)singleInit;
@@ -1105 +1314 @@
         }
 
-        void previsit( ast::ListInit * listInit ) {
+        void Resolver_new::previsit( const ast::ListInit * listInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)listInit;
@@ -1111 +1320 @@
         }
 
-        void previsit( ast::ConstructorInit * ctorInit ) {
+        void Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)ctorInit;

src/ResolvExpr/module.mk

@@ -19 +19 @@
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/Candidate.cpp \
+      ResolvExpr/CandidateFinder.cpp \
       ResolvExpr/CastCost.cc \
       ResolvExpr/CommonType.cc \

src/ResolvExpr/typeops.h

@@ -103 +103 @@
 
         bool typesCompatible( 
-                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
+                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {}, 
                 const ast::TypeEnvironment & env = {} );
         

src/SynTree/BaseSyntaxNode.h

@@ -41 +41 @@
   /// * Expressions should not finish with a newline, since the expression's parent has better information.
         virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
-  void print( std::ostream & os, unsigned int indent ) {
-    print( os, Indenter{ Indenter::tabsize, indent });
-  }
 };
 

src/SynTree/DeclReplacer.cc

@@ -30 +30 @@
                         bool debug;
                 public:
+                        size_t replaced;
+
+                public:
                         DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
 
@@ -45 +48 @@
                         bool debug;
                 public:
+                        size_t replaced;
+
+                public:
                         ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
 
@@ -52 +58 @@
         }
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
                 PassVisitor<DeclReplacer> replacer( declMap, typeMap, debug );
                 maybeAccept( node, replacer );
+                return replacer.pass.replaced;
         }
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
                 TypeMap typeMap;
-                replace( node, declMap, typeMap, debug );
+                return replace( node, declMap, typeMap, debug );
         }
 
-        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
+        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug ) {
                 DeclMap declMap;
-                replace( node, declMap, typeMap, debug );
+                return replace( node, declMap, typeMap, debug );
         }
 
-        void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
+        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
                 PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
                 node = maybeMutate( node, replacer );
+                return replacer.pass.replaced;
         }
 
         namespace {
-                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ) {}
+                DeclReplacer::DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug ) : declMap( declMap ), typeMap( typeMap ) , debug( debug ), replaced( 0 ) {}
 
                 // replace variable with new node from decl map
@@ -79 +87 @@
                         // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
                         if ( declMap.count( varExpr->var ) ) {
+                                replaced++;
                                 auto replacement = declMap.at( varExpr->var );
                                 if ( debug ) {
@@ -89 +98 @@
                 void DeclReplacer::previsit( TypeInstType * inst ) {
                         if ( typeMap.count( inst->baseType ) ) {
+                                replaced++;
                                 auto replacement = typeMap.at( inst->baseType );
                                 if ( debug ) {
@@ -97 +107 @@
                 }
 
-                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ) {}
+                ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ), replaced( 0 ) {}
 
                 Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
                         if ( exprMap.count( varExpr->var ) ) {
+                                replaced++;
                                 Expression * replacement = exprMap.at( varExpr->var )->clone();
                                 if ( debug ) {

src/SynTree/DeclReplacer.h

@@ -28 +28 @@
         typedef std::map< DeclarationWithType *, Expression * > ExprMap;
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
-        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
+        size_t replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
 
-        void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
+        size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
         template<typename T>
                 void replace( T *& node, const ExprMap & exprMap, bool debug = false ) {

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  3 17:35:59 2019
-// Update Count     : 600
+// Last Modified On : Wed Jun  5 20:35:13 2019
+// Update Count     : 601
 //
 
@@ -406 +406 @@
 
 
-static const char optstring[] = ":hlLmNn:pP:S:twW:D:F:";
+static const char optstring[] = ":hlLmNnpP:S:twW:D:F:";
 
 enum { PreludeDir = 128 };