Changeset 5b643ea

Timestamp:

Aug 16, 2024, 12:06:25 PM (7 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

afb15cf

Parents:

cef5bfc (diff), 8da3cc4d (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

Files:

• src/GenPoly/GenPoly.cpp (modified) (4 diffs)
• src/ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)
• tests/.expect/poly-many-arsz.txt (added)
• tests/array-collections/.expect/accordion.txt (added)
• tests/array-collections/accordion.cfa (added)
• tests/array-collections/dimexpr-match.hfa (modified) (1 diff)
• tests/poly-many-arsz.cfa (added)
• tests/raii/.expect/typeof-member.txt (added)
• tests/raii/typeof-member.cfa (added)

src/GenPoly/GenPoly.cpp ¶

@@ -27 +27 @@
 #include "AST/Type.hpp"
 #include "AST/TypeSubstitution.hpp"
+#include "Common/Eval.hpp"                // for eval
 #include "GenPoly/ErasableScopedMap.hpp"  // for ErasableScopedMap<>::const_...
 #include "ResolvExpr/Typeops.hpp"         // for flatten
@@ -243 +244 @@
 } // namespace
 
+// This function, and its helpers following, have logic duplicated from
+// unification.  The difference in context is that unification applies where
+// the types "must" match, while this variation applies to arbitrary type
+// pairs, when an optimization could apply if they happen to match.  This
+// variation does not bind type variables.  The helper functions support
+// the case for matching ArrayType.
+bool typesPolyCompatible( ast::Type const * lhs, ast::Type const * rhs );
+
+static bool exprsPolyCompatibleByStaticValue(
+                const ast::Expr * e1, const ast::Expr * e2 ) {
+        Evaluation r1 = eval(e1);
+        Evaluation r2 = eval(e2);
+
+        if ( !r1.hasKnownValue ) return false;
+        if ( !r2.hasKnownValue ) return false;
+
+        if ( r1.knownValue != r2.knownValue ) return false;
+
+        return true;
+}
+
+static bool exprsPolyCompatible( ast::Expr const * lhs,
+                ast::Expr const * rhs ) {
+        type_index const lid = typeid(*lhs);
+        type_index const rid = typeid(*rhs);
+        if ( lid != rid ) return false;
+
+        if ( exprsPolyCompatibleByStaticValue( lhs, rhs ) ) return true;
+
+        if ( type_index(typeid(ast::CastExpr)) == lid ) {
+                ast::CastExpr const * l = as<ast::CastExpr>(lhs);
+                ast::CastExpr const * r = as<ast::CastExpr>(rhs);
+
+                // inspect casts' target types
+                if ( !typesPolyCompatible(
+                        l->result, r->result ) ) return false;
+
+                // inspect casts' inner expressions
+                return exprsPolyCompatible( l->arg, r->arg );
+
+        } else if ( type_index(typeid(ast::VariableExpr)) == lid ) {
+                ast::VariableExpr const * l = as<ast::VariableExpr>(lhs);
+                ast::VariableExpr const * r = as<ast::VariableExpr>(rhs);
+
+                assert(l->var);
+                assert(r->var);
+
+                // conservative: variable exprs match if their declarations are
+                // represented by the same C++ AST object
+                return (l->var == r->var);
+
+        } else if ( type_index(typeid(ast::SizeofExpr)) == lid ) {
+                ast::SizeofExpr const * l = as<ast::SizeofExpr>(lhs);
+                ast::SizeofExpr const * r = as<ast::SizeofExpr>(rhs);
+
+                assert((l->type != nullptr) ^ (l->expr != nullptr));
+                assert((r->type != nullptr) ^ (r->expr != nullptr));
+                if ( !(l->type && r->type) ) return false;
+
+                // mutual recursion with type poly compatibility
+                return typesPolyCompatible( l->type, r->type );
+
+        } else {
+                // All other forms compare on static value only, done earlier
+                return false;
+        }
+}
+
 bool typesPolyCompatible( ast::Type const * lhs, ast::Type const * rhs ) {
         type_index const lid = typeid(*lhs);
@@ -256 +325 @@
 
         // So remaining types can be examined case by case.
-        // Recurse through type structure (conditions borrowed from Unify.cpp).
+        // Recurse through type structure (conditions duplicated from Unify.cpp).
 
         if ( type_index(typeid(ast::BasicType)) == lid ) {
@@ -280 +349 @@
                 ast::ArrayType const * r = as<ast::ArrayType>(rhs);
 
-                if ( l->isVarLen ) {
-                        if ( !r->isVarLen ) return false;
-                } else {
-                        if ( r->isVarLen ) return false;
-
-                        auto lc = l->dimension.as<ast::ConstantExpr>();
-                        auto rc = r->dimension.as<ast::ConstantExpr>();
-                        if ( lc && rc && lc->intValue() != rc->intValue() ) {
+                if ( l->isVarLen != r->isVarLen ) return false;
+                if ( (l->dimension != nullptr) != (r->dimension != nullptr) )
+                        return false;
+
+                if ( l->dimension ) {
+                        assert( r->dimension );
+                        // mutual recursion with expression poly compatibility
+                        if ( !exprsPolyCompatible(l->dimension, r->dimension) )
                                 return false;
-                        }
                 }
 

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -1241 +1241 @@
                 Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
+                        ast::ptr< ast::Type > fromType = cand->expr->result;
+                        assert( fromType );
+                        fromType = resolveTypeof( fromType, context );
+                        fromType = adjustExprType( fromType, tenv, symtab );
+
                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
                         ast::OpenVarSet open( cand->open );
@@ -1250 +1255 @@
                         // subexpression results that are cast directly. The candidate is invalid if it
                         // has fewer results than there are types to cast to.
-                        int discardedValues = cand->expr->result->size() - toType->size();
+                        int discardedValues = fromType->size() - toType->size();
                         if ( discardedValues < 0 ) continue;
 
                         // unification run for side-effects
-                        unify( toType, cand->expr->result, cand->env, need, have, open );
+                        unify( toType, fromType, cand->env, need, have, open );
                         Cost thisCost =
                                 (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
-                                        ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
-                                        : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
+                                        ? conversionCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                                        : castCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env );
                         
                         // Redefine enum cast
-                        auto argAsEnum = cand->expr->result.as<ast::EnumInstType>();
+                        auto argAsEnum = fromType.as<ast::EnumInstType>();
                         auto toAsEnum = toType.as<ast::EnumInstType>();
                         if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {
@@ -1272 +1277 @@
                         PRINT(
                                 std::cerr << "working on cast with result: " << toType << std::endl;
-                                std::cerr << "and expr type: " << cand->expr->result << std::endl;
+                                std::cerr << "and expr type: " << fromType << std::endl;
                                 std::cerr << "env: " << cand->env << std::endl;
                         )
@@ -1281 +1286 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
+
+                                // See Aaron Moss, page 47; this reasoning does not hold since implicit conversions
+                                // can create the same resolution issue. The C intrinsic interpretations are pruned
+                                // immediately for the lowest cost option regardless of result type. Related code in
+                                // postvisit (UntypedExpr).
+                                // Cast expression costs are updated now to use the general rules.
+                                /*
                                 // select first on argument cost, then conversion cost
                                 if ( cand->cost < minExprCost || ( cand->cost == minExprCost && thisCost < minCastCost ) ) {
@@ -1289 +1301 @@
                                 // ambigious case, still output candidates to print in error message
                                 if ( cand->cost == minExprCost && thisCost == minCastCost ) {
+                                */
+                                cand->cost += thisCost;
+                                if (cand->cost < minExprCost) {
+                                        minExprCost = cand->cost;
+                                        matches.clear();
+                                }
+                                if (cand->cost == minExprCost) {
                                         CandidateRef newCand = std::make_shared<Candidate>(
                                                 restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost + thisCost);
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost);
                                         // 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)

tests/array-collections/dimexpr-match.hfa ¶

@@ -15 +15 @@
 //
 //      compiler=gcc -x c           # pick one
-//      compiler=$fa
+//      compiler=$cfa
 //
 //      test=dimexpr-match-c.cfa    # pick one