Changeset c84dd61 for src

Timestamp:

Jun 21, 2023, 2:38:55 AM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

92355883

Parents:

0b0a285 (diff), 2de175ce (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (2 diffs)
• AST/SymbolTable.cpp (modified) (2 diffs)
• AST/Type.hpp (modified) (1 diff)
• AST/TypeEnvironment.cpp (modified) (1 diff)
• AST/TypeEnvironment.hpp (modified) (1 diff)
• Concurrency/Actors.cpp (modified) (7 diffs)
• GenPoly/SpecializeNew.cpp (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (7 diffs)
• Parser/ExpressionNode.cc (modified) (2 diffs)
• Parser/ExpressionNode.h (modified) (1 diff)
• Parser/parser.yy (modified) (3 diffs)
• ResolvExpr/Candidate.hpp (modified) (2 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (21 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• ResolvExpr/CastCost.cc (modified) (1 diff)
• ResolvExpr/CommonType.cc (modified) (4 diffs)
• ResolvExpr/ConversionCost.cc (modified) (5 diffs)
• ResolvExpr/FindOpenVars.cc (modified) (3 diffs)
• ResolvExpr/FindOpenVars.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/SatisfyAssertions.cpp (modified) (15 diffs)
• ResolvExpr/Unify.cc (modified) (6 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (1 diff)
• Validate/Autogen.cpp (modified) (4 diffs)
• Validate/GenericParameter.cpp (modified) (2 diffs)
• Validate/LinkReferenceToTypes.cpp (modified) (5 diffs)
• Virtual/VirtualDtor.cpp (modified) (1 diff)
• main.cc (modified) (3 diffs)

src/AST/Convert.cpp

@@ -2343 +2343 @@
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
-                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast,
+                                (ast::CastExpr::CastKind) old->kind
                         )
                 );

src/AST/Expr.cpp

@@ -186 +186 @@
 // --- CastExpr
 
-CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g )
-: Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
+CastExpr::CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g, CastKind kind )
+: Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ), kind( kind ) {}
 
 bool CastExpr::get_lvalue() const {

src/AST/Expr.hpp

@@ -55 +55 @@
                 const Expr * e )
         : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
+
+        operator bool() {return declptr;}
 };
 
@@ -335 +337 @@
         GeneratedFlag isGenerated;
 
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+
+        CastKind kind = Default;
+
         CastExpr( const CodeLocation & loc, const Expr * a, const Type * to,
-                GeneratedFlag g = GeneratedCast ) : Expr( loc, to ), arg( a ), isGenerated( g ) {}
+                GeneratedFlag g = GeneratedCast, CastKind kind = Default ) : Expr( loc, to ), arg( a ), isGenerated( g ), kind( kind ) {}
         /// Cast-to-void
-        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
+        CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast, CastKind kind = Default );
 
         /// Wrap a cast expression around an existing expression (always generated)

src/AST/SymbolTable.cpp

@@ -19 +19 @@
 
 #include "Copy.hpp"
+#include <iostream>
+#include <algorithm>
+
 #include "Decl.hpp"
 #include "Expr.hpp"
@@ -203 +206 @@
                         out.push_back(decl.second);
                 }
+
+                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
         }
 

src/AST/Type.hpp

@@ -451 +451 @@
         bool operator==(const TypeEnvKey & other) const;
         bool operator<(const TypeEnvKey & other) const;
-};
+        operator bool() {return base;}
+};
+
 
 /// tuple type e.g. `[int, char]`

src/AST/TypeEnvironment.cpp

@@ -135 +135 @@
                 }
         }
-        sub.normalize();
+        // sub.normalize();
 }
 

src/AST/TypeEnvironment.hpp

@@ -63 +63 @@
 
                 int cmp = d1->var->name.compare( d2->var->name );
-                return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
+                return cmp > 0 || ( cmp == 0 && d1->result < d2->result );
         }
 };

src/Concurrency/Actors.cpp

@@ -223 +223 @@
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
             //////////////////////////////////////////////////////////////////////
+            // The following generates this wrapper for all receive(derived_actor &, derived_msg &) functions
+            /* base_actor and base_msg are output params
+            static inline allocation __CFA_receive_wrap( derived_actor & receiver, derived_msg & msg, actor ** base_actor, message ** base_msg ) {
+                base_actor = &receiver;
+                base_msg = &msg;
+                return receive( receiver, msg );
+            }
+            */
+            CompoundStmt * wrapBody = new CompoundStmt( decl->location );
+
+            // generates: base_actor = &receiver;
+            wrapBody->push_back( new ExprStmt( decl->location,
+                UntypedExpr::createAssign( decl->location, 
+                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_actor" ) ),
+                    new AddressExpr( decl->location, new NameExpr( decl->location, "receiver" ) )
+                )
+            ));
+
+            // generates: base_msg = &msg;
+            wrapBody->push_back( new ExprStmt( decl->location,
+                UntypedExpr::createAssign( decl->location, 
+                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_msg" ) ),
+                    new AddressExpr( decl->location, new NameExpr( decl->location, "msg" ) )
+                )
+            ));
+
+            // generates: return receive( receiver, msg );
+            wrapBody->push_back( new ReturnStmt( decl->location,
+                new UntypedExpr ( decl->location,
+                    new NameExpr( decl->location, "receive" ),
+                    {
+                        new NameExpr( decl->location, "receiver" ),
+                        new NameExpr( decl->location, "msg" )
+                    }
+                )
+            ));
+
+            // create receive wrapper to extract base message and actor pointer
+            // put it all together into the complete function decl from above
+            FunctionDecl * receiveWrapper = new FunctionDecl(
+                decl->location,
+                "__CFA_receive_wrap",
+                {},                     // forall
+                {
+                    new ObjectDecl(
+                        decl->location,
+                        "receiver",
+                        ast::deepCopy( derivedActorRef )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "msg",
+                        ast::deepCopy( derivedMsgRef )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "base_actor",
+                        new PointerType( new PointerType( new StructInstType( *actorDecl ) ) )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "base_msg",
+                        new PointerType( new PointerType( new StructInstType( *msgDecl ) ) )
+                    )
+                },                      // params
+                { 
+                    new ObjectDecl(
+                        decl->location,
+                        "__CFA_receive_wrap_ret",
+                        new EnumInstType( *allocationDecl )
+                    )
+                },
+                wrapBody,               // body
+                { Storage::Static },    // storage
+                Linkage::Cforall,       // linkage
+                {},                     // attributes
+                { Function::Inline }
+            );
+
+            declsToAddAfter.push_back( receiveWrapper );
+
+            //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
             /*
@@ -246 +328 @@
             ));
             
-            // Function type is: allocation (*)( derived_actor &, derived_msg & )
+            // Function type is: allocation (*)( derived_actor &, derived_msg &, actor **, message ** )
             FunctionType * derivedReceive = new FunctionType();
             derivedReceive->params.push_back( ast::deepCopy( derivedActorRef ) );
             derivedReceive->params.push_back( ast::deepCopy( derivedMsgRef ) );
+            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
+            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             derivedReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
-            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
+            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg &, actor **, message ** ) = receive;
             sendBody->push_back( new DeclStmt(
                 decl->location,
@@ -259 +343 @@
                     "my_work_fn",
                     new PointerType( derivedReceive ),
-                    new SingleInit( decl->location, new NameExpr( decl->location, "receive" ) )
+                    new SingleInit( decl->location, new NameExpr( decl->location, "__CFA_receive_wrap" ) )
                 )
             ));
@@ -267 +351 @@
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *msgDecl ) ) );
+            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
+            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
@@ -285 +371 @@
             ));
 
-            // Generates: new_req{ &receiver, &msg, fn };
+            // Generates: new_req{ (actor *)&receiver, (message *)&msg, fn };
             sendBody->push_back( new ExprStmt(
                 decl->location,
@@ -293 +379 @@
                                         {
                                                 new NameExpr( decl->location, "new_req" ),
-                        new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
-                        new AddressExpr( new NameExpr( decl->location, "msg" ) ),
+                        new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "receiver" ) ), new PointerType( new StructInstType( *actorDecl ) ), ExplicitCast ),
+                        new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "msg" ) ), new PointerType( new StructInstType( *msgDecl ) ), ExplicitCast ),
                         new NameExpr( decl->location, "fn" )
                                         }
@@ -321 +407 @@
             FunctionDecl * sendOperatorFunction = new FunctionDecl(
                 decl->location,
-                "?<<?",
+                "?|?",
                 {},                     // forall
                 {

src/GenPoly/SpecializeNew.cpp

@@ -113 +113 @@
         using namespace ResolvExpr;
         ast::OpenVarSet openVars, closedVars;
-        ast::AssertionSet need, have;
-        findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
-        findOpenVars( actualType, openVars, closedVars, need, have, FirstOpen );
+        ast::AssertionSet need, have; // unused
+        ast::TypeEnvironment env; // unused
+        // findOpenVars( formalType, openVars, closedVars, need, have, FirstClosed );
+        findOpenVars( actualType, openVars, closedVars, need, have, env, FirstOpen );
         for ( const ast::OpenVarSet::value_type & openVar : openVars ) {
                 const ast::Type * boundType = subs->lookup( openVar.first );
@@ -125 +126 @@
                         if ( closedVars.find( *inst ) == closedVars.end() ) {
                                 return true;
+                        }
+                        else {
+                                assertf(false, "closed: %s", inst->name.c_str());
                         }
                 // Otherwise, the variable is bound to a concrete type.

src/Parser/DeclarationNode.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Thr Apr 20 11:46:00 2023
-// Update Count     : 1393
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jun 17 14:41:48 2023
+// Update Count     : 1405
 //
 
@@ -459 +459 @@
         std::vector<ast::ptr<ast::Expr>> exprs;
         buildList( expr, exprs );
-        newnode->attributes.push_back(
-                new ast::Attribute( *name, std::move( exprs ) ) );
+        newnode->attributes.push_back( new ast::Attribute( *name, std::move( exprs ) ) );
         delete name;
         return newnode;
@@ -633 +632 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::basicTypeNames[ dst->basictype ] +
+                                                                   "\" and \"" + DeclarationNode::basicTypeNames[ src->basictype ] + "\"." );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
+                                        SemanticError( yylloc, string( "multiple declaration types \"" ) + DeclarationNode::complexTypeNames[ src->complextype ] +
+                                                                   "\" and \"" + DeclarationNode::complexTypeNames[ src->complextype ] + "\"." );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::signednessNames[ dst->signedness ] +
+                                                                   "\" and \"" + DeclarationNode::signednessNames[ src->signedness ] + "\"." );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -650 +652 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
+                                        SemanticError( yylloc, string( "conflicting type specifier \"" ) + DeclarationNode::lengthNames[ dst->length ] +
+                                                                   "\" and \"" + DeclarationNode::lengthNames[ src->length ] + "\"." );
                         } // if
                         break;
@@ -718 +721 @@
 
 DeclarationNode * DeclarationNode::addEnumBase( DeclarationNode * o ) {
-        if ( o && o -> type)  {
+        if ( o && o->type)  {
                 type->base= o->type;
-        }
+        } // if
         delete o;
         return this;
@@ -1003 +1006 @@
 }
 
-// If a typedef wraps an anonymous declaration, name the inner declaration
-// so it has a consistent name across translation units.
+// If a typedef wraps an anonymous declaration, name the inner declaration so it has a consistent name across
+// translation units.
 static void nameTypedefedDecl(
                 DeclarationNode * innerDecl,
@@ -1085 +1088 @@
 }
 
-void buildList( DeclarationNode * firstNode,
-                std::vector<ast::ptr<ast::Decl>> & outputList ) {
+void buildList( DeclarationNode * firstNode, std::vector<ast::ptr<ast::Decl>> & outputList ) {
         SemanticErrorException errors;
         std::back_insert_iterator<std::vector<ast::ptr<ast::Decl>>> out( outputList );

src/Parser/ExpressionNode.cc

@@ -601 +601 @@
 ast::Expr * build_cast( const CodeLocation & location,
                 DeclarationNode * decl_node,
-                ExpressionNode * expr_node ) {
+                ExpressionNode * expr_node,
+                ast::CastExpr::CastKind kind ) {
         ast::Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast<ast::VoidType *>( targetType ) ) {
@@ -607 +608 @@
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
-                        ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } else {
                 return new ast::CastExpr( location,
                         maybeMoveBuild( expr_node ),
                         targetType,
-                        ast::ExplicitCast );
+                        ast::ExplicitCast, kind );
         } // if
 } // build_cast

src/Parser/ExpressionNode.h

@@ -69 +69 @@
 ast::DimensionExpr * build_dimensionref( const CodeLocation &, const std::string * name );
 
-ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );
+ast::Expr * build_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node, ast::CastExpr::CastKind kind = ast::CastExpr::Default );
 ast::Expr * build_keyword_cast( const CodeLocation &, ast::AggregateDecl::Aggregate target, ExpressionNode * expr_node );
 ast::Expr * build_virtual_cast( const CodeLocation &, DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  7 14:32:28 2023
-// Update Count     : 6341
+// Last Modified On : Sat Jun 17 18:53:24 2023
+// Update Count     : 6347
 //
 
@@ -931 +931 @@
                 { $$ = new ExpressionNode( new ast::VirtualCastExpr( yylloc, maybeMoveBuild( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_cast( yylloc, $3, $5, ast::CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }
@@ -1040 +1040 @@
                 // FIX ME: computes $1 twice
         | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
-                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_cond( yylloc, $1, $1->clone(), $4 ) ); }
         ;
 

src/ResolvExpr/Candidate.hpp

@@ -91 +91 @@
 
 /// Holdover behaviour from old `findMinCost` -- xxx -- can maybe be eliminated?
+/*
 static inline void promoteCvtCost( CandidateList & candidates ) {
         for ( CandidateRef & r : candidates ) {
@@ -96 +97 @@
         }
 }
+*/
 
 void print( std::ostream & os, const Candidate & cand, Indenter indent = {} );

src/ResolvExpr/CandidateFinder.cpp

@@ -38 +38 @@
 #include "typeops.h"              // for combos
 #include "Unify.h"
+#include "WidenMode.h"
 #include "AST/Expr.hpp"
 #include "AST/Node.hpp"
@@ -749 +750 @@
                         // attempt to narrow based on expected target type
                         const ast::Type * returnType = funcType->returns.front();
-                        if ( ! unify(
-                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
-                        ) {
-                                // unification failed, do not pursue this candidate
-                                return;
+                        if ( selfFinder.strictMode ) {
+                                if ( ! unifyExact(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden() ) // xxx - is no widening correct?
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
+                        }
+                        else {
+                                if ( ! unify(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen )
+                                ) {
+                                        // unification failed, do not pursue this candidate
+                                        return;
+                                }
                         }
                 }
@@ -771 +782 @@
                                 for (size_t i=0; i<nParams; ++i) {
                                         auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
-                                        if (!instantiateArgument( location,
+                                        if ( !instantiateArgument( location,
                                                 funcType->params[i], obj->init, args, results, genStart, symtab)) return;
                                 }
@@ -781 +792 @@
                         // matches
                         // no default args for indirect calls
-                        if ( ! instantiateArgument( location,
+                        if ( !instantiateArgument( location,
                                 param, nullptr, args, results, genStart, symtab ) ) return;
                 }
@@ -874 +885 @@
 
                 if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
-                        addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
+                        addAggMembers( structInst, aggrExpr, *cand, Cost::unsafe, "" );
                 } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
-                        addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
+                        addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
                 }
         }
@@ -1007 +1018 @@
                                 if ( auto pointer = dynamic_cast< const ast::PointerType * >( funcResult ) ) {
                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
+                                                // if (!selfFinder.allowVoid && function->returns.empty()) continue;
                                                 CandidateRef newFunc{ new Candidate{ *func } };
                                                 newFunc->expr =
@@ -1018 +1030 @@
                                         if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
                                                 if ( auto function = clz->bound.as< ast::FunctionType >() ) {
-                                                        CandidateRef newFunc{ new Candidate{ *func } };
+                                                        CandidateRef newFunc( new Candidate( *func ) );
                                                         newFunc->expr =
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
@@ -1060 +1072 @@
                 if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
 
+                // only keep the best matching intrinsic result to match C semantics (no unexpected narrowing/widening)
+                // TODO: keep one for each set of argument candidates?
+                Cost intrinsicCost = Cost::infinity;
+                CandidateList intrinsicResult;
+
                 // Compute conversion costs
                 for ( CandidateRef & withFunc : found ) {
@@ -1082 +1099 @@
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
-                                candidates.emplace_back( std::move( withFunc ) );
-                        }
-                }
+                                withFunc->cost += cvtCost;
+                                auto func = withFunc->expr.strict_as<ast::ApplicationExpr>()->func.as<ast::VariableExpr>();
+                                if (func && func->var->linkage == ast::Linkage::Intrinsic) {
+                                        if (withFunc->cost < intrinsicCost) {
+                                                intrinsicResult.clear();
+                                                intrinsicCost = withFunc->cost;
+                                        }
+                                        if (withFunc->cost == intrinsicCost) {
+                                                intrinsicResult.emplace_back(std::move(withFunc));
+                                        }
+                                }
+                                else {
+                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
+                }
+                spliceBegin( candidates, intrinsicResult );
                 found = std::move( candidates );
 
                 // use a new list so that candidates are not examined by addAnonConversions twice
-                CandidateList winners = findMinCost( found );
-                promoteCvtCost( winners );
+                // CandidateList winners = findMinCost( found );
+                // promoteCvtCost( winners );
 
                 // function may return a struct/union value, in which case we need to add candidates
                 // for implicit conversions to each of the anonymous members, which must happen after
                 // `findMinCost`, since anon conversions are never the cheapest
-                for ( const CandidateRef & c : winners ) {
+                for ( const CandidateRef & c : found ) {
                         addAnonConversions( c );
                 }
-                spliceBegin( candidates, winners );
-
-                if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
+                // would this be too slow when we don't check cost anymore?
+                spliceBegin( candidates, found );
+
+                if ( candidates.empty() && targetType && ! targetType->isVoid() && !selfFinder.strictMode ) {
                         // If resolution is unsuccessful with a target type, try again without, since it
                         // will sometimes succeed when it wouldn't with a target type binding.
@@ -1140 +1172 @@
 
                 CandidateFinder finder( context, tenv, toType );
+                if (toType->isVoid()) {
+                        finder.allowVoid = true;
+                }
+                if ( castExpr->kind == ast::CastExpr::Return ) {
+                        finder.strictMode = true;
+                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+
+                        // return casts are eliminated (merely selecting an overload, no actual operation)
+                        candidates = std::move(finder.candidates);
+                }
                 finder.find( castExpr->arg, ResolvMode::withAdjustment() );
 
@@ -1145 +1187 @@
 
                 CandidateList matches;
+                Cost minExprCost = Cost::infinity;
+                Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
@@ -1176 +1220 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-                                CandidateRef newCand = std::make_shared<Candidate>(
-                                        restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                        copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
-                                        cand->cost + thisCost );
-                                inferParameters( newCand, matches );
-                        }
-                }
-
-                // select first on argument cost, then conversion cost
-                CandidateList minArgCost = findMinCost( matches );
-                promoteCvtCost( minArgCost );
-                candidates = findMinCost( minArgCost );
+                                // select first on argument cost, then conversion cost
+                                if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                        minExprCost = cand->cost;
+                                        minCastCost = thisCost;
+                                        matches.clear();
+
+
+                                }
+                                // ambiguous case, still output candidates to print in error message
+                                if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
+                                        // currently assertions are always resolved immediately so this should have no effect. 
+                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                        // we may need to revisit the logic.
+                                        inferParameters( newCand, matches );
+                                }
+                                // else skip, better alternatives found
+
+                        }
+                }
+                candidates = std::move(matches);
+
+                //CandidateList minArgCost = findMinCost( matches );
+                //promoteCvtCost( minArgCost );
+                //candidates = findMinCost( minArgCost );
         }
 
@@ -1453 +1512 @@
                 // candidates for true result
                 CandidateFinder finder2( context, tenv );
+                finder2.allowVoid = true;
                 finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
@@ -1458 +1518 @@
                 // candidates for false result
                 CandidateFinder finder3( context, tenv );
+                finder3.allowVoid = true;
                 finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                 if ( finder3.candidates.empty() ) return;
@@ -1524 +1585 @@
         void Finder::postvisit( const ast::ConstructorExpr * ctorExpr ) {
                 CandidateFinder finder( context, tenv );
+                finder.allowVoid = true;
                 finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
                 for ( CandidateRef & r : finder.candidates ) {
@@ -1640 +1702 @@
                         CandidateFinder finder( context, tenv, toType );
                         finder.find( initExpr->expr, ResolvMode::withAdjustment() );
+
+                        Cost minExprCost = Cost::infinity;
+                        Cost minCastCost = Cost::infinity;
                         for ( CandidateRef & cand : finder.candidates ) {
                                 if (reason.code == NotFound) reason.code = NoMatch;
@@ -1677 +1742 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                new ast::InitExpr{
-                                                        initExpr->location, restructureCast( cand->expr, toType ),
-                                                        initAlt.designation },
-                                                std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
-                                        inferParameters( newCand, matches );
+                                        if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
+                                                minExprCost = cand->cost;
+                                                minCastCost = thisCost;
+                                                matches.clear();
+                                        }
+                                        // ambiguous case, still output candidates to print in error message
+                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        new ast::InitExpr{
+                                                                initExpr->location,
+                                                                restructureCast( cand->expr, toType ),
+                                                                initAlt.designation },
+                                                        std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
+                                                // currently assertions are always resolved immediately so this should have no effect.
+                                                // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                                // we may need to revisit the logic.
+                                                inferParameters( newCand, matches );
+                                        }
                                 }
                         }
@@ -1688 +1765 @@
 
                 // select first on argument cost, then conversion cost
-                CandidateList minArgCost = findMinCost( matches );
-                promoteCvtCost( minArgCost );
-                candidates = findMinCost( minArgCost );
+                // CandidateList minArgCost = findMinCost( matches );
+                // promoteCvtCost( minArgCost );
+                // candidates = findMinCost( minArgCost );
+                candidates = std::move(matches);
         }
 
@@ -1756 +1834 @@
                         auto found = selected.find( mangleName );
                         if ( found != selected.end() ) {
-                                if ( newCand->cost < found->second.candidate->cost ) {
+                                // tiebreaking by picking the lower cost on CURRENT expression
+                                // NOTE: this behavior is different from C semantics.
+                                // Specific remediations are performed for C operators at postvisit(UntypedExpr).
+                                // Further investigations may take place.
+                                if ( newCand->cost < found->second.candidate->cost
+                                        || (newCand->cost == found->second.candidate->cost && newCand->cvtCost < found->second.candidate->cvtCost) ) {
                                         PRINT(
                                                 std::cerr << "cost " << newCand->cost << " beats "
@@ -1763 +1846 @@
 
                                         found->second = PruneStruct{ newCand };
-                                } else if ( newCand->cost == found->second.candidate->cost ) {
+                                } else if ( newCand->cost == found->second.candidate->cost && newCand->cvtCost == found->second.candidate->cvtCost ) {
                                         // if one of the candidates contains a deleted identifier, can pick the other,
                                         // since deleted expressions should not be ambiguous if there is another option
@@ -1854 +1937 @@
         */
 
-        if ( mode.prune ) {
+        // optimization: don't prune for NameExpr since it never has cost
+        if ( mode.prune && !dynamic_cast<const ast::NameExpr *>(expr) ) {
                 // trim candidates to single best one
                 PRINT(

src/ResolvExpr/CandidateFinder.hpp

@@ -33 +33 @@
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
+        bool strictMode = false;           ///< If set to true, requires targetType to be exact match (inside return cast)
+        bool allowVoid = false;            ///< If set to true, allow void-returning function calls (only top level, cast to void and first in comma)
         std::set< std::string > otypeKeys;  /// different type may map to same key
 

src/ResolvExpr/CastCost.cc

@@ -234 +234 @@
         if ( typesCompatibleIgnoreQualifiers( src, dst, env ) ) {
                 PRINT( std::cerr << "compatible!" << std::endl; )
+                if (dynamic_cast<const ast::ZeroType *>(dst) || dynamic_cast<const ast::OneType *>(dst)) {
+                        return Cost::spec;
+                }
                 return Cost::zero;
         } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {

src/ResolvExpr/CommonType.cc

@@ -697 +697 @@
                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 #warning remove casts when `commonTypes` moved to new AST
+                                
+                                /*
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
                                 if (
@@ -706 +708 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
                                 }
+                                */
+                                ast::BasicType::Kind kind;
+                                if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
+                                else if (!widen.first) kind = basic->kind; // widen.second
+                                else if (!widen.second) kind = basic2->kind;
+                                else kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
+                                // xxx - what does qualifiers even do here??
+                                if ( (basic->qualifiers >= basic2->qualifiers || widen.first)
+                                        && (basic->qualifiers <= basic2->qualifiers || widen.second) ) {
+                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
+                                }
+                                
                         } else if (
                                 dynamic_cast< const ast::ZeroType * >( type2 )
@@ -712 +726 @@
                                 #warning remove casts when `commonTypes` moved to new AST
                                 ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
-                                if (
-                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+                                /*
+                                if ( // xxx - what does qualifier even do here??
+                                        ( ( basic->qualifiers >= type2->qualifiers )
                                                 || widen.first )
-                                        && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                         && ( ( /* kind != basic->kind && basic->qualifiers <= type2->qualifiers )
                                                 || widen.second )
-                                ) {
-                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                ) 
+                                */
+                                if (widen.second) {
+                                        result = new ast::BasicType{ basic->kind, basic->qualifiers | type2->qualifiers };
                                 }
                         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
@@ -746 +763 @@
                                 auto entry = open.find( *var );
                                 if ( entry != open.end() ) {
+                                // if (tenv.lookup(*var)) {
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(

src/ResolvExpr/ConversionCost.cc

@@ -702 +702 @@
 
         cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
+
+        // xxx - should qualifiers be considered in pass-by-value?
+        /*
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -709 +712 @@
                 cost.incUnsafe();
         }
+        */
+        cost.incReference();
 }
 
@@ -792 +797 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
+                // this has the effect of letting any expr such as x+0, x+1 to be typed
+                // the same as x, instead of at least int. are we willing to sacrifice this little
+                // bit of coherence with C?
+                // TODO: currently this does not work when no zero/one overloads exist. Find a fix for it.
+                // cost = Cost::zero;
         } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
                 cost = Cost::zero;
                 // +1 for zero_t ->, +1 for disambiguation
                 cost.incSafe( maxIntCost + 2 );
+                // assuming 0p is supposed to be used for pointers?
         }
 }
@@ -804 +815 @@
                 cost = Cost::zero;
         } else if ( const ast::BasicType * dstAsBasic =
-                        dynamic_cast< const ast::BasicType * >( dst ) ) {
+                        dynamic_cast< const ast::BasicType * >( dst ) ) {               
                 int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
                 if ( -1 == tableResult ) {
@@ -813 +824 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
+                
+                // cost = Cost::zero;
         }
 }

src/ResolvExpr/FindOpenVars.cc

@@ -21 +21 @@
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "Common/PassVisitor.h"
 #include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
 #include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
+
+#include <iostream>
 
 namespace ResolvExpr {
@@ -102 +105 @@
                         ast::AssertionSet & need;
                         ast::AssertionSet & have;
+                        ast::TypeEnvironment & env;
                         bool nextIsOpen;
 
                         FindOpenVars_new(
                                 ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
-                                ast::AssertionSet & h, FirstMode firstIsOpen )
-                        : open( o ), closed( c ), need( n ), have( h ), nextIsOpen( firstIsOpen ) {}
+                                ast::AssertionSet & h, ast::TypeEnvironment & env, FirstMode firstIsOpen )
+                        : open( o ), closed( c ), need( n ), have( h ), env (env), nextIsOpen( firstIsOpen ) {}
 
                         void previsit( const ast::FunctionType * type ) {
                                 // mark open/closed variables
                                 if ( nextIsOpen ) {
+                                        // trying to remove this from resolver.
+                                        // occasionally used in other parts so not deleting right now.
+
+                                        // insert open variables unbound to environment.
+                                        env.add(type->forall);
+
                                         for ( auto & decl : type->forall ) {
                                                 open[ *decl ] = ast::TypeData{ decl->base };
@@ -137 +147 @@
         void findOpenVars(
                         const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
-                        ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen ) {
-                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, firstIsOpen };
+                        ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen ) {
+                ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, env, firstIsOpen };
                 type->accept( finder );
+
+                if (!closed.empty()) {
+                        std::cerr << "closed: ";
+                        for (auto& i : closed) {
+                                std::cerr << i.first.base->location << ":" << i.first.base->name << ' ';
+                        }
+                        std::cerr << std::endl;
+                }
         }
 } // namespace ResolvExpr

src/ResolvExpr/FindOpenVars.h

@@ -33 +33 @@
         void findOpenVars( 
                 const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed, 
-                ast::AssertionSet & need, ast::AssertionSet & have, FirstMode firstIsOpen );
+                ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen );
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1011 +1011 @@
                         ast::TypeEnvironment env;
                         CandidateFinder finder( context, env );
+                        finder.allowVoid = true;
                         finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
                         --recursion_level;
@@ -1054 +1055 @@
 
                         // promote candidate.cvtCost to .cost
-                        promoteCvtCost( winners );
+                        // promoteCvtCost( winners );
 
                         // produce ambiguous errors, if applicable

src/ResolvExpr/SatisfyAssertions.cpp

@@ -16 +16 @@
 #include "SatisfyAssertions.hpp"
 
+#include <iostream>
 #include <algorithm>
 #include <cassert>
@@ -45 +46 @@
 #include "SymTab/Mangler.h"
 
+
+
 namespace ResolvExpr {
 
@@ -65 +68 @@
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
-                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
+                  need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {
+                        if (!have.empty()) {
+                                // std::cerr << c.id->location << ':' << c.id->name << std::endl; // I think this was debugging code so I commented it
+                        }
+                  }
         };
 
@@ -139 +146 @@
         };
 
-        /// Adds a captured assertion to the symbol table
-        void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
-                for ( auto & i : have ) {
-                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
-                }
-        }
+        enum AssertionResult {Fail, Skip, Success} ;
 
         /// Binds a single assertion, updating satisfaction state
@@ -155 +157 @@
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
 
-                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
+                ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cost );
                 varExpr->result = match.adjType;
                 if ( match.resnSlot ) { varExpr->inferred.resnSlots().emplace_back( match.resnSlot ); }
@@ -165 +167 @@
 
         /// Satisfy a single assertion
-        bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool allowConversion = false, bool skipUnbound = false) {
+        AssertionResult satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool skipUnbound = false) {
                 // skip unused assertions
-                if ( ! assn.second.isUsed ) return true;
+                // static unsigned int cnt = 0; // I think this was debugging code so I commented it
+                if ( ! assn.second.isUsed ) return AssertionResult::Success;
+
+                // if (assn.first->var->name[1] == '|') std::cerr << ++cnt << std::endl; // I think this was debugging code so I commented it
 
                 // find candidates that unify with the desired type
-                AssnCandidateList matches;
+                AssnCandidateList matches, inexactMatches;
 
                 std::vector<ast::SymbolTable::IdData> candidates;
@@ -179 +184 @@
                                 .strict_as<ast::FunctionType>()->params[0]
                                 .strict_as<ast::ReferenceType>()->base;
-                        sat.cand->env.apply(thisArgType);
+                        // sat.cand->env.apply(thisArgType);
+
+                        if (auto inst = thisArgType.as<ast::TypeInstType>()) {
+                                auto cls = sat.cand->env.lookup(*inst);
+                                if (cls && cls->bound) thisArgType = cls->bound;
+                        }
 
                         std::string otypeKey = "";
                         if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
                         else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
-                        else if (skipUnbound) return false;
+                        else if (skipUnbound) return AssertionResult::Skip;
 
                         candidates = sat.symtab.specialLookupId(kind, otypeKey);
@@ -212 +222 @@
 
                         ast::OpenVarSet closed;
-                        findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
-                        findOpenVars( adjType, newOpen, closed, newNeed, have, FirstOpen );
-                        if ( allowConversion ) {
+                        // findOpenVars( toType, newOpen, closed, newNeed, have, FirstClosed );
+                        findOpenVars( adjType, newOpen, closed, newNeed, have, newEnv, FirstOpen );
+                        ast::TypeEnvironment tempNewEnv {newEnv};
+
+                        if ( unifyExact( toType, adjType, tempNewEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
+                                // set up binding slot for recursive assertions
+                                ast::UniqueId crntResnSlot = 0;
+                                if ( ! newNeed.empty() ) {
+                                        crntResnSlot = ++globalResnSlot;
+                                        for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
+                                }
+
+                                matches.emplace_back(
+                                        cdata, adjType, std::move( tempNewEnv ), std::move( have ), std::move( newNeed ),
+                                        std::move( newOpen ), crntResnSlot );
+                        }
+                        else if ( matches.empty() ) {
+                                // restore invalidated env
+                                // newEnv = sat.cand->env;
+                                // newNeed.clear();
                                 if ( auto c = commonType( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
                                         // set up binding slot for recursive assertions
@@ -223 +250 @@
                                         }
 
-                                        matches.emplace_back(
+                                        inexactMatches.emplace_back(
                                                 cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                                 std::move( newOpen ), crntResnSlot );
                                 }
                         }
-                        else {
-                                if ( unifyExact( toType, adjType, newEnv, newNeed, have, newOpen, WidenMode {true, true} ) ) {
-                                        // set up binding slot for recursive assertions
-                                        ast::UniqueId crntResnSlot = 0;
-                                        if ( ! newNeed.empty() ) {
-                                                crntResnSlot = ++globalResnSlot;
-                                                for ( auto & a : newNeed ) { a.second.resnSlot = crntResnSlot; }
-                                        }
-
-                                        matches.emplace_back(
-                                                cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
-                                                std::move( newOpen ), crntResnSlot );
-                                }
-                        }
                 }
 
                 // break if no satisfying match
-                if ( matches.empty() ) return false;
+                if ( matches.empty() ) matches = std::move(inexactMatches);
+                if ( matches.empty() ) return AssertionResult::Fail;
 
                 // defer if too many satisfying matches
                 if ( matches.size() > 1 ) {
                         sat.deferred.emplace_back( assn.first, assn.second, std::move( matches ) );
-                        return true;
+                        return AssertionResult::Success;
                 }
 
                 // otherwise bind unique match in ongoing scope
                 AssnCandidate & match = matches.front();
-                addToSymbolTable( match.have, sat.symtab );
+                // addToSymbolTable( match.have, sat.symtab );
                 sat.newNeed.insert( match.need.begin(), match.need.end() );
                 sat.cand->env = std::move( match.env );
@@ -261 +275 @@
 
                 bindAssertion( assn.first, assn.second, sat.cand, match, sat.inferred );
-                return true;
+                return AssertionResult::Success;
         }
 
@@ -438 +452 @@
                 // for each current mutually-compatible set of assertions
                 for ( SatState & sat : sats ) {
-                        bool allowConversion = false;
                         // stop this branch if a better option is already found
                         auto it = thresholds.find( pruneKey( *sat.cand ) );
@@ -447 +460 @@
                         for (unsigned resetCount = 0; ; ++resetCount) {
                                 ast::AssertionList next;
-                                resetTyVarRenaming();
                                 // make initial pass at matching assertions
                                 for ( auto & assn : sat.need ) {
+                                        resetTyVarRenaming();
                                         // fail early if any assertion is not satisfiable
-                                        if ( ! satisfyAssertion( assn, sat, allowConversion, !next.empty() ) ) {
-                                                next.emplace_back(assn);
-                                                // goto nextSat;
-                                        }
-                                }
-                                // success
-                                if (next.empty()) break;
-                                // fail if nothing resolves
-                                else if (next.size() == sat.need.size()) {
-                                        if (allowConversion) {
+                                        auto result = satisfyAssertion( assn, sat, !next.empty() );
+                                        if ( result == AssertionResult::Fail ) {
                                                 Indenter tabs{ 3 };
                                                 std::ostringstream ss;
@@ -466 +471 @@
                                                 print( ss, *sat.cand, ++tabs );
                                                 ss << (tabs-1) << "Could not satisfy assertion:\n";
-                                                ast::print( ss, next[0].first, tabs );
+                                                ast::print( ss, assn.first, tabs );
 
                                                 errors.emplace_back( ss.str() );
                                                 goto nextSat;
                                         }
-
-                                        else {
-                                                allowConversion = true;
-                                                continue;
-                                        }
-                                }
-                                allowConversion = false;
+                                        else if ( result == AssertionResult::Skip ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+
                                 sat.need = std::move(next);
                         }
@@ -531 +537 @@
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
-                                                sat.cand->cost, sat.cand->cvtCost );
+                                                sat.cand->cost );
 
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
@@ -544 +550 @@
                                         for ( DeferRef r : compat.assns ) {
                                                 AssnCandidate match = r.match;
-                                                addToSymbolTable( match.have, nextSymtab );
+                                                // addToSymbolTable( match.have, nextSymtab );
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );
 

src/ResolvExpr/Unify.cc

@@ -160 +160 @@
                 env.apply( newSecond );
 
-                findOpenVars( newFirst, open, closed, need, have, FirstClosed );
-                findOpenVars( newSecond, open, closed, need, have, FirstOpen );
+                // findOpenVars( newFirst, open, closed, need, have, FirstClosed );
+                findOpenVars( newSecond, open, closed, need, have, newEnv, FirstOpen );
 
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
@@ -964 +964 @@
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const XInstType * >( other );
-                        if (otherInst && inst->name == otherInst->name) this->result = otherInst;
+                        if (otherInst && inst->name == otherInst->name) 
+                                this->result = otherInst;
                         return otherInst;
                 }
@@ -1049 +1050 @@
 
                 void postvisit( const ast::TypeInstType * typeInst ) {
-                        assert( open.find( *typeInst ) == open.end() );
-                        handleRefType( typeInst, type2 );
+                        // assert( open.find( *typeInst ) == open.end() );
+                        auto otherInst = dynamic_cast< const ast::TypeInstType * >( type2 );
+                        if (otherInst && typeInst->name == otherInst->name) 
+                                this->result = otherInst;
+                        // return otherInst;
                 }
 
@@ -1161 +1165 @@
         ) {
                 ast::OpenVarSet closed;
-                findOpenVars( type1, open, closed, need, have, FirstClosed );
-                findOpenVars( type2, open, closed, need, have, FirstOpen );
+                // findOpenVars( type1, open, closed, need, have, FirstClosed );
+                findOpenVars( type2, open, closed, need, have, env, FirstOpen );
                 return unifyInexact(
                         type1, type2, env, need, have, open, WidenMode{ true, true }, common );
@@ -1179 +1183 @@
                         entry1 = var1 ? open.find( *var1 ) : open.end(),
                         entry2 = var2 ? open.find( *var2 ) : open.end();
-                bool isopen1 = entry1 != open.end();
-                bool isopen2 = entry2 != open.end();
-
+                // bool isopen1 = entry1 != open.end();
+                // bool isopen2 = entry2 != open.end();
+                bool isopen1 = var1 && env.lookup(*var1);
+                bool isopen2 = var2 && env.lookup(*var2);
+
+                /*
                 if ( isopen1 && isopen2 ) {
                         if ( entry1->second.kind != entry2->second.kind ) return false;
@@ -1190 +1197 @@
                         return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
                 } else if ( isopen2 ) {
-                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen );
-                } else {
+                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
+                } */
+                if ( isopen1 && isopen2 ) {
+                        if ( var1->base->kind != var2->base->kind ) return false;
+                        return env.bindVarToVar(
+                                var1, var2, ast::TypeData{ var1->base->kind, var1->base->sized||var2->base->sized }, need, have,
+                                open, widen );
+                } else if ( isopen1 ) {
+                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen );
+                } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
+                }else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen );
                 }
+                
         }
 

src/SynTree/Expression.cc

@@ -267 +267 @@
 }
 
-CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kind ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, bool isGenerated, CastKind kind ) : arg(arg), isGenerated( isGenerated ), kind( kind ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ), kind( other.kind ) {
 }
 

src/SynTree/Expression.h

@@ -271 +271 @@
         bool isGenerated = true;
 
-        CastExpr( Expression * arg, bool isGenerated = true );
-        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        enum CastKind {
+                Default, // C
+                Coerce, // reinterpret cast
+                Return  // overload selection
+        };
+
+        CastKind kind = Default;
+
+        CastExpr( Expression * arg, bool isGenerated = true, CastKind kind = Default );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true, CastKind kind = Default );
         CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );

src/Tuples/TupleAssignment.cc

@@ -679 +679 @@
 
                                 ResolvExpr::CandidateFinder finder( crntFinder.context, matcher->env );
+                                finder.allowVoid = true;
 
                                 try {

src/Validate/Autogen.cpp

@@ -321 +321 @@
 void FuncGenerator::produceDecl( const ast::FunctionDecl * decl ) {
         assert( nullptr != decl->stmts );
+        assert( decl->type_params.size() == getGenericParams( type ).size() );
 
         definitions.push_back( decl );
@@ -356 +357 @@
                 decl->init = nullptr;
                 splice( assertions, decl->assertions );
-                oldToNew.emplace( std::make_pair( old_param, decl ) );
+                oldToNew.emplace( old_param, decl );
                 type_params.push_back( decl );
         }
@@ -522 +523 @@
         InitTweak::InitExpander_new srcParam( src );
         // Assign to destination.
-        ast::Expr * dstSelect = new ast::MemberExpr(
+        ast::MemberExpr * dstSelect = new ast::MemberExpr(
                 location,
                 field,
@@ -574 +575 @@
                 }
 
-                ast::Expr * srcSelect = (srcParam) ? new ast::MemberExpr(
+                ast::MemberExpr * srcSelect = (srcParam) ? new ast::MemberExpr(
                         location, field, new ast::VariableExpr( location, srcParam )
                 ) : nullptr;

src/Validate/GenericParameter.cpp

@@ -120 +120 @@
 }
 
-struct ValidateGenericParamsCore : public ast::WithCodeLocation {
+bool isSizedPolymorphic( const ast::AggregateDecl * decl ) {
+        for ( const auto & param : decl->params ) {
+                if ( param->sized ) return true;
+        }
+        return false;
+}
+
+struct ValidateGenericParamsCore :
+                public ast::WithCodeLocation, public ast::WithGuards {
+        // Generic parameter filling and checks:
         const ast::StructInstType * previsit( const ast::StructInstType * type ) {
                 assert( location );
@@ -129 +138 @@
                 assert( location );
                 return validateGeneric( *location, type );
+        }
+
+        // Check parameter and bitfield combinations:
+        bool insideSized = false;
+        void previsit( const ast::StructDecl * decl ) {
+                if ( isSizedPolymorphic( decl ) && !insideSized ) {
+                        GuardValue( insideSized ) = true;
+                }
+        }
+
+        void previsit( const ast::UnionDecl * decl ) {
+                if ( isSizedPolymorphic( decl ) && !insideSized ) {
+                        GuardValue( insideSized ) = true;
+                }
+        }
+
+        void previsit( const ast::ObjectDecl * decl ) {
+                if ( insideSized && decl->bitfieldWidth ) {
+                        SemanticError( decl->location, decl,
+                                "Cannot have bitfields inside a sized polymorphic structure." );
+                }
         }
 };

src/Validate/LinkReferenceToTypes.cpp

@@ -84 +84 @@
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
-                mut->base = const_cast<ast::EnumDecl *>( decl );
+                mut->base = decl;
                 type = mut;
         }
@@ -101 +101 @@
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
-                mut->base = const_cast<ast::StructDecl *>( decl );
+                mut->base = decl;
                 type = mut;
         }
@@ -118 +118 @@
                 // Just linking in the node.
                 auto mut = ast::mutate( type );
-                mut->base = const_cast<ast::UnionDecl *>( decl );
+                mut->base = decl;
                 type = mut;
         }
@@ -141 +141 @@
 
         // Just linking in the node.
-        mut->base = const_cast<ast::TraitDecl *>( decl );
+        mut->base = decl;
 
         // Need to carry over the 'sized' status of each decl in the instance.
@@ -203 +203 @@
         }
 
-        // The following section 
-
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );
         if ( fwds != forwardEnums.end() ) {

src/Virtual/VirtualDtor.cpp

@@ -146 +146 @@
 
             CompoundStmt * dtorBody = mutate( decl->stmts.get() );
-            // Adds the following to the end of any actor/message dtor:
+            // Adds the following to the start of any actor/message dtor:
             //  __CFA_dtor_shutdown( this );
-            dtorBody->push_front( new ExprStmt(
-                decl->location,
-                                new UntypedExpr (
-                    decl->location,
-                                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
-                                        {
-                        new NameExpr( decl->location, decl->params.at(0)->name )
-                                        }
-                                )
-                        ));
+            dtorBody->push_front( 
+                new IfStmt( decl->location,
+                    new UntypedExpr (
+                        decl->location,
+                        new NameExpr( decl->location, "__CFA_dtor_shutdown" ),
+                        {
+                            new NameExpr( decl->location, decl->params.at(0)->name )
+                        }
+                    ),
+                    new ReturnStmt( decl->location, nullptr )
+                )
+            );
             return;
         }

src/main.cc

@@ -28 +28 @@
 #include <list>                             // for list
 #include <string>                           // for char_traits, operator<<
-
-using namespace std;
 
 #include "AST/Convert.hpp"
@@ -88 +86 @@
 #include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
 
+using namespace std;
+
 static void NewPass( const char * const name ) {
         Stats::Heap::newPass( name );
@@ -335 +335 @@
 
                 PASS( "Fix Qualified Types", Validate::fixQualifiedTypes, transUnit );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
                 PASS( "Hoist Struct", Validate::hoistStruct, transUnit );
-                PASS( "Eliminate Typedef", Validate::eliminateTypedef, transUnit );
                 PASS( "Validate Generic Parameters", Validate::fillGenericParameters, transUnit );
                 PASS( "Translate Dimensions", Validate::translateDimensionParameters, transUnit );