Changeset 46da46b

Timestamp:

May 2, 2023, 3:44:31 AM (12 months ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

0c840fc

Parents:

1ab773e0

Message:

current progress

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (2 diffs)
• AST/Type.hpp (modified) (1 diff)
• AST/TypeEnvironment.cpp (modified) (1 diff)
• GenPoly/SpecializeNew.cpp (modified) (2 diffs)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/Candidate.hpp (modified) (2 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (19 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) (5 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (1 diff)

src/AST/Convert.cpp

@@ -2331 +2331 @@
                                 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;}
 };
 
@@ -334 +336 @@
         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/Type.hpp

@@ -454 +454 @@
         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/GenPoly/SpecializeNew.cpp

@@ -112 +112 @@
         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 );
@@ -124 +125 @@
                         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/ExpressionNode.cc

@@ -544 +544 @@
 }; // OperName
 
-Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
+Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node, CastExpr::CastKind kind ) {
         Type * targetType = maybeMoveBuildType( decl_node );
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false, kind );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false, kind );
         } // if
 } // build_cast

src/Parser/ParseNode.h

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

src/Parser/parser.yy

@@ -905 +905 @@
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild<Expression>( $5 ), maybeMoveBuildType( $3 ) ) ); }
         | '(' RETURN type_no_function ')' cast_expression       // CFA
-                { SemanticError( yylloc, "Return cast is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new ExpressionNode( build_cast( $3, $5, CastExpr::Return ) ); }
         | '(' COERCE type_no_function ')' cast_expression       // CFA
                 { SemanticError( yylloc, "Coerce cast is currently unimplemented." ); $$ = nullptr; }

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

@@ -30 +30 @@
 #include "Resolver.h"
 #include "ResolveTypeof.h"
+#include "WidenMode.h"
 #include "SatisfyAssertions.hpp"
 #include "typeops.h"              // for adjustExprType, conversionCost, polyCost, specCost
@@ -700 +701 @@
                                 // attempt to narrow based on expected target type
                                 const ast::Type * returnType = funcType->returns.front();
-                                if ( ! unify(
-                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
-                                ) {
-                                        // unification failed, do not pursue this candidate
-                                        return;
+                                if ( selfFinder.strictMode ) {
+                                        if ( ! unifyExact(
+                                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, noWiden(), symtab ) // xxx - is no widening correct?
+                                        ) {
+                                                // unification failed, do not pursue this candidate
+                                                return;
+                                        }
+                                }
+                                else {
+                                        if ( ! unify(
+                                                returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                                        ) {
+                                                // unification failed, do not pursue this candidate
+                                                return;
+                                        }
                                 }
                         }
@@ -825 +836 @@
 
                         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, "" );
                         }
                 }
@@ -958 +969 @@
                                         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 =
@@ -1008 +1020 @@
                         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 ) {
@@ -1030 +1047 @@
                                 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.
@@ -1093 +1125 @@
 
                         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() );
 
@@ -1098 +1140 @@
 
                         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;
@@ -1129 +1173 @@
                                         // 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 );
                 }
 
@@ -1261 +1320 @@
 
                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
-                                        cost );
+                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, cost );
 
                                 if (newCand->expr->env) {
@@ -1407 +1465 @@
                         // candidates for true result
                         CandidateFinder finder2( context, tenv );
+                        finder2.allowVoid = true;
                         finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
                         if ( finder2.candidates.empty() ) return;
@@ -1412 +1471 @@
                         // candidates for false result
                         CandidateFinder finder3( context, tenv );
+                        finder3.allowVoid = true;
                         finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                         if ( finder3.candidates.empty() ) return;
@@ -1478 +1538 @@
                 void postvisit( const ast::ConstructorExpr * ctorExpr ) {
                         CandidateFinder finder( context, tenv );
+                        finder.allowVoid = true;
                         finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
                         for ( CandidateRef & r : finder.candidates ) {
@@ -1594 +1655 @@
                                 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;
@@ -1631 +1695 @@
                                                 // count one safe conversion for each value that is thrown away
                                                 thisCost.incSafe( discardedValues );
-                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                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 );
-                                                inferParameters( newCand, matches );
-                                        }
+                                                        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 );
+                                                }
+
+                                        }
+                                        
                                 }
 
@@ -1643 +1720 @@
 
                         // 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);
                 }
 
@@ -1724 +1802 @@
                         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 "
@@ -1731 +1814 @@
 
                                         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
@@ -1822 +1905 @@
         */
 
-        if ( mode.prune ) {
+        // 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

@@ -229 +229 @@
         if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, 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

@@ -695 +695 @@
                         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 (
@@ -704 +706 @@
                                         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 )
@@ -710 +724 @@
                                 #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 ) ) {
@@ -744 +761 @@
                                 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

@@ -1009 +1009 @@
                         ast::TypeEnvironment env;
                         CandidateFinder finder( context, env );
+                        finder.allowVoid = true;
                         finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
                         --recursion_level;
@@ -1052 +1053 @@
 
                         // 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>
@@ -42 +43 @@
 #include "SymTab/Mangler.h"
 
+
+
 namespace ResolvExpr {
 
@@ -62 +65 @@
                         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;
+                        }
+                  }
         };
 
@@ -136 +143 @@
         };
 
-        /// 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 ); }
-                }
-        }
+
 
         /// Binds a single assertion, updating satisfaction state
@@ -152 +154 @@
                         "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 ); }
@@ -162 +164 @@
 
         /// Satisfy a single assertion
-        bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool allowConversion = false, bool skipUnbound = false) {
+        bool satisfyAssertion( ast::AssertionList::value_type & assn, SatState & sat, bool skipUnbound = false) {
                 // skip unused assertions
+                static unsigned int cnt = 0;
                 if ( ! assn.second.isUsed ) return true;
 
+                if (assn.first->var->name[1] == '|') std::cerr << ++cnt << std::endl;
+
                 // find candidates that unify with the desired type
-                AssnCandidateList matches;
+                AssnCandidateList matches, inexactMatches;
 
                 std::vector<ast::SymbolTable::IdData> candidates;
@@ -209 +214 @@
 
                         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}, sat.symtab ) ) {
+                                // 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}, sat.symtab ) ) {
                                         // set up binding slot for recursive assertions
@@ -220 +242 @@
                                         }
 
-                                        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}, sat.symtab ) ) {
-                                        // 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() ) matches = std::move(inexactMatches);
                 if ( matches.empty() ) return false;
 
@@ -252 +261 @@
                 // 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 );
@@ -435 +444 @@
                 // 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 ) );
@@ -448 +456 @@
                                 for ( auto & assn : sat.need ) {
                                         // fail early if any assertion is not satisfiable
-                                        if ( ! satisfyAssertion( assn, sat, allowConversion, !next.empty() ) ) {
+                                        if ( ! satisfyAssertion( assn, sat, !next.empty() ) ) {
                                                 next.emplace_back(assn);
                                                 // goto nextSat;
@@ -457 +465 @@
                                 // fail if nothing resolves
                                 else if (next.size() == sat.need.size()) {
-                                        if (allowConversion) {
+                                        // if (allowConversion) {
                                                 Indenter tabs{ 3 };
                                                 std::ostringstream ss;
@@ -467 +475 @@
                                                 errors.emplace_back( ss.str() );
                                                 goto nextSat;
-                                        }
-
-                                        else {
-                                                allowConversion = true;
-                                                continue;
-                                        }
-                                }
-                                allowConversion = false;
+                                        // }
+
+                                        // else {
+                                        //      allowConversion = true;
+                                        //      continue;
+                                        // }
+                                }
                                 sat.need = std::move(next);
                         }
@@ -528 +535 @@
                                                 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 };
@@ -541 +548 @@
                                         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

@@ -134 +134 @@
                 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(), symtab );
@@ -1029 +1029 @@
 
                 void postvisit( const ast::TypeInstType * typeInst ) {
-                        assert( open.find( *typeInst ) == open.end() );
+                        // assert( open.find( *typeInst ) == open.end() );
                         handleRefType( typeInst, type2 );
                 }
@@ -1142 +1142 @@
         ) {
                 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 }, symtab, common );
@@ -1160 +1160 @@
                         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;
@@ -1172 +1175 @@
                 } else if ( isopen2 ) {
                         return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
-                } else {
+                } */
+                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, symtab );
+                } else if ( isopen1 ) {
+                        return env.bindVar( var1, type2, ast::TypeData{var1->base}, need, have, open, widen, symtab );
+                } else if ( isopen2 ) {
+                        return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen, symtab );
+                }else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen, symtab );
                 }
+                
         }
 

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 {