Changeset b7b3e41 for src/ResolvExpr

Timestamp:

Jun 19, 2023, 1:57:11 PM (3 years ago)

Author:

caparson <caparson@…>

Branches:

master, stuck-waitfor-destruct

Children:

adc73a5

Parents:

fa5e1aa5 (diff), 33d4bc8 (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/ResolvExpr

Files:

• Candidate.hpp (modified) (2 diffs)
• CandidateFinder.cpp (modified) (21 diffs)
• CandidateFinder.hpp (modified) (1 diff)
• CastCost.cc (modified) (1 diff)
• CommonType.cc (modified) (5 diffs)
• ConversionCost.cc (modified) (5 diffs)
• CurrentObject.cc (modified) (2 diffs)
• FindOpenVars.cc (modified) (3 diffs)
• FindOpenVars.h (modified) (1 diff)
• Resolver.cc (modified) (7 diffs)
• SatisfyAssertions.cpp (modified) (15 diffs)
• Unify.cc (modified) (6 diffs)

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(
@@ -1017 +1035 @@
                 void postvisit( const ast::TraitInstType * ) {}
 
-                void postvisit( const ast::TypeInstType * inst ) {}
-
-                void postvisit( const ast::TupleType * tuple) {
+                void postvisit( const ast::TypeInstType * ) {}
+
+                void postvisit( const ast::TupleType * tuple ) {
                         tryResolveWithTypedEnum( tuple );
                 }

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/CurrentObject.cc

@@ -689 +689 @@
 
                         auto arg = eval( expr );
-                        index = arg.first;
+                        assertf( arg.hasKnownValue, "Non-evaluable expression made it to IndexIterator" );
+                        index = arg.knownValue;
 
                         // if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
@@ -728 +729 @@
                 size_t getSize( const Expr * expr ) {
                         auto res = eval( expr );
-                        if ( !res.second ) {
+                        if ( !res.hasKnownValue ) {
                                 SemanticError( location, toString( "Array designator must be a constant expression: ", expr ) );
                         }
-                        return res.first;
+                        return res.knownValue;
                 }
 

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
@@ -1106 +1107 @@
 
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
-                void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
+                void removeExtraneousCast( ast::ptr<ast::Expr> & expr ) {
                         if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result ) ) {
@@ -1196 +1197 @@
                 ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
                 ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, context );
-                removeExtraneousCast( newExpr, context.symtab );
+                removeExtraneousCast( newExpr );
                 return newExpr;
         }
@@ -1261 +1262 @@
                 static size_t traceId;
                 Resolver_new( const ast::TranslationGlobal & global ) :
+                        ast::WithSymbolTable(ast::SymbolTable::ErrorDetection::ValidateOnAdd),
                         context{ symtab, global } {}
                 Resolver_new( const ResolveContext & context ) :
@@ -1340 +1342 @@
                                         auto mutAttr = mutate(attr);
                                         mutAttr->params.front() = resolved;
-                                        if (! result.second) {
+                                        if (! result.hasKnownValue) {
                                                 SemanticWarning(loc, Warning::GccAttributes,
                                                         toCString( name, " priorities must be integers from 0 to 65535 inclusive: ", arg ) );
                                         }
                                         else {
-                                                auto priority = result.first;
+                                                auto priority = result.knownValue;
                                                 if (priority < 101) {
                                                         SemanticWarning(loc, Warning::GccAttributes,
@@ -2040 +2042 @@
                 const ast::Type * initContext = currentObject.getCurrentType();
 
-                removeExtraneousCast( newExpr, symtab );
+                removeExtraneousCast( newExpr );
 
                 // check if actual object's type is char[]

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 );
                 }
+                
         }