Changeset b6f2e7ab for src/ResolvExpr

Timestamp:

Sep 9, 2024, 5:15:32 PM (6 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

f5dbc8d

Parents:

5c6d439

Message:

Removed SizeofExpr::expr and AlignofExpr::expr, expressions that would be stored there are wrapped in TypeofType? and stored in the type field. Some special cases to hide the typeof in code generation were added. In addition, initializer length is calculated in more cases so that the full type of more arrays is known sooner. Other than that, most of the code changes were just stripping out the conditional code and checks no longer needed. Some tests had to be updated, because the typeof is not hidden in dumps and the resolver replaces known typeof expressions with the type. The extension case caused some concern but it appears that just hides warnings in the expression which no longer exists.

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (2 diffs)
• Unify.cpp (modified) (1 diff)

src/ResolvExpr/CandidateFinder.cpp

@@ -1482 +1482 @@
 
         void Finder::postvisit( const ast::SizeofExpr * sizeofExpr ) {
-                if ( sizeofExpr->type ) {
-                        addCandidate(
-                                new ast::SizeofExpr{
-                                        sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
-                                tenv );
-                } else {
-                        // find all candidates for the argument to sizeof
-                        CandidateFinder finder( context, tenv );
-                        finder.find( sizeofExpr->expr );
-                        // find the lowest-cost candidate, otherwise ambiguous
-                        CandidateList winners = findMinCost( finder.candidates );
-                        if ( winners.size() != 1 ) {
-                                SemanticError(
-                                        sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
-                        }
-                        // return the lowest-cost candidate
-                        CandidateRef & choice = winners.front();
-                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                        choice->cost = Cost::zero;
-                        addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
-                }
+                addCandidate(
+                        new ast::SizeofExpr{
+                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
+                        tenv );
         }
 
@@ -1537 +1520 @@
 
         void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
-                if ( alignofExpr->type ) {
-                        addCandidate(
-                                new ast::AlignofExpr{
-                                        alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
-                                tenv );
-                } else {
-                        // find all candidates for the argument to alignof
-                        CandidateFinder finder( context, tenv );
-                        finder.find( alignofExpr->expr );
-                        // find the lowest-cost candidate, otherwise ambiguous
-                        CandidateList winners = findMinCost( finder.candidates );
-                        if ( winners.size() != 1 ) {
-                                SemanticError(
-                                        alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
-                        }
-                        // return the lowest-cost candidate
-                        CandidateRef & choice = winners.front();
-                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                        choice->cost = Cost::zero;
-                        addCandidate(
-                                *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
-                }
+                addCandidate(
+                        new ast::AlignofExpr{
+                                alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
+                        tenv );
         }
 

src/ResolvExpr/Unify.cpp

@@ -234 +234 @@
                         if ( !e2so ) return;
 
-                        assert((e1->type != nullptr) ^ (e1->expr != nullptr));
-                        assert((e2so->type != nullptr) ^ (e2so->expr != nullptr));
-                        if ( !(e1->type && e2so->type) ) return;
-
                         // expression unification calls type unification (mutual recursion)
                         result = unifyExact( e1->type, e2so->type, tenv, need, have, open, widen );