Changeset 857b5f9

Timestamp:

Jan 23, 2025, 12:09:40 PM (3 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

9e72bae3

Parents:

829821c

Message:

CountExpr? -> CountofExpr?. Actually the main fix was making countof use the same pattern as sizeof/alignof, using a typeof to combine the two cases and have one field instead of two.

Location:

src

Files:

• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (2 diffs)
• AST/Print.cpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (6 diffs)

src/AST/Expr.cpp ¶

@@ -283 +283 @@
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
 
-// --- CountExpr
-
-CountExpr::CountExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(e), type( nullptr ) {}
-
-CountExpr::CountExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(nullptr), type( t ) {}
-
 // --- AlignofExpr
 
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
+
+// --- CountofExpr
+
+CountofExpr::CountofExpr( const CodeLocation & loc, const Type * t )
+: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), type( t ) {}
 
 // --- OffsetofExpr

src/AST/Expr.hpp ¶

@@ -490 +490 @@
 };
 
-class CountExpr final : public Expr {
-public:
-        ptr<Expr> expr;
-        ptr<Type> type;
-
-        CountExpr( const CodeLocation & loc, const Expr * t );
-        CountExpr( const CodeLocation & loc, const Type * t );
-
-        const Expr * accept( Visitor & v )const override { return v.visit( this ); }
-private:
-        CountExpr * clone() const override { return new CountExpr( *this ); }
-        MUTATE_FRIEND
-};
-
 /// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
 class AlignofExpr final : public Expr {
@@ -514 +500 @@
 private:
         AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// countof expression, e.g. `countof(AnEnum)`, `countof pred(Head)`
+class CountofExpr final : public Expr {
+public:
+        ptr<Type> type;
+
+        CountofExpr( const CodeLocation & loc, const Type * t );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CountofExpr * clone() const override { return new CountofExpr( *this ); }
         MUTATE_FRIEND
 };

src/AST/Fwd.hpp ¶

@@ -86 +86 @@
 class ConstantExpr;
 class SizeofExpr;
-class CountExpr;
 class AlignofExpr;
+class CountofExpr;
 class UntypedOffsetofExpr;
 class OffsetofExpr;

src/AST/Pass.hpp ¶

@@ -173 +173 @@
         const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
         const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
-        const ast::Expr *             visit( const ast::CountExpr            * ) override final;
         const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
+        const ast::Expr *             visit( const ast::CountofExpr          * ) override final;
         const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;
         const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;

src/AST/Pass.impl.hpp ¶

@@ -1350 +1350 @@
 
 //--------------------------------------------------------------------------
-// CountExpr
-template< typename core_t >
-const ast::Expr * ast::Pass< core_t >::visit( const ast::CountExpr * node ) {
-        VISIT_START( node );
-        if ( __visit_children() ) {
-                {
-                        guard_symtab guard { *this };
-                        maybe_accept( node, &CountExpr::result );
-                }
-                if ( node->type ) {
-                        maybe_accept( node, &CountExpr::type );
-                } else {
-                        maybe_accept( node, &CountExpr::expr );
-                }
-        }
-        VISIT_END( Expr, node );
-}
-
-//--------------------------------------------------------------------------
 // AlignofExpr
 template< typename core_t >
@@ -1380 +1361 @@
                 }
                 maybe_accept( node, &AlignofExpr::type );
+        }
+
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// CountofExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CountofExpr * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                {
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &CountofExpr::result );
+                }
+                maybe_accept( node, &CountofExpr::type );
         }
 

src/AST/Print.cpp ¶

@@ -1207 +1207 @@
         }
 
-        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
+        virtual const ast::Expr * visit( const ast::CountofExpr * node ) override final {
                 os << "Count Expression on: ";
                 ++indent;
-                if ( node->type ) node->type->accept( *this );
-                else safe_print( node->expr );
+                safe_print( node->type );
                 --indent;
                 postprint( node );

src/AST/Visitor.hpp ¶

@@ -76 +76 @@
     virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) = 0;
-    virtual const ast::Expr *             visit( const ast::CountExpr            * ) = 0;
     virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) = 0;
+    virtual const ast::Expr *             visit( const ast::CountofExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) = 0;
     virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;

src/Common/CodeLocationTools.cpp ¶

@@ -154 +154 @@
     macro(ConstantExpr, Expr) \
     macro(SizeofExpr, Expr) \
-    macro(CountExpr, Expr ) \
     macro(AlignofExpr, Expr) \
+    macro(CountofExpr, Expr ) \
     macro(UntypedOffsetofExpr, Expr) \
     macro(OffsetofExpr, Expr) \

src/Parser/parser.yy ¶

@@ -946 +946 @@
                 }
         | COUNTOF unary_expression
-                { $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::CountofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
         | COUNTOF '(' type_no_function ')'
-                { $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+                { $$ = new ExpressionNode( new ast::CountofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         ;
 

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -672 +672 @@
                 void postvisit( const ast::SizeofExpr * sizeofExpr );
                 void postvisit( const ast::AlignofExpr * alignofExpr );
+                void postvisit( const ast::CountofExpr * countExpr );
                 void postvisit( const ast::AddressExpr * addressExpr );
                 void postvisit( const ast::LabelAddressExpr * labelExpr );
@@ -697 +698 @@
                 void postvisit( const ast::UntypedInitExpr * initExpr );
                 void postvisit( const ast::QualifiedNameExpr * qualifiedExpr );
-                void postvisit( const ast::CountExpr * countExpr );
 
                 void postvisit( const ast::InitExpr * ) {
@@ -941 +941 @@
                 }
         }
-        
 
         /// Adds aggregate member interpretations
@@ -1269 +1268 @@
                                         ? 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 = fromType.as<ast::EnumInstType>();
@@ -1493 +1492 @@
         }
 
-        void Finder::postvisit( const ast::CountExpr * countExpr ) {
-                const ast::UntypedExpr * untyped = nullptr;
-                if ( countExpr->type ) {
-                        auto enumInst = countExpr->type.as<ast::EnumInstType>();
-                        if ( enumInst ) {
-                                addCandidate( ast::ConstantExpr::from_ulong(countExpr->location, enumInst->base->members.size()), tenv );
-                                return;
-                        }
-                        auto untypedFirst = ast::UntypedExpr::createCall( countExpr->location, "lowerBound", {} );
-                        auto castFirst = new ast::CastExpr( countExpr->location, untypedFirst , countExpr->type );
-                        untyped = ast::UntypedExpr::createCall(
-                                countExpr->location, "Countof", { castFirst }
-                        );
-                }
-                if (!untyped) untyped = ast::UntypedExpr::createCall(
-                                countExpr->location, "Countof", { countExpr->expr }
+        void Finder::postvisit( const ast::CountofExpr * countExpr ) {
+                if ( auto enumInst = countExpr->type.as<ast::EnumInstType>() ) {
+                        addCandidate( ast::ConstantExpr::from_ulong( countExpr->location, enumInst->base->members.size()), tenv );
+                        return;
+                }
+                auto untypedFirst = ast::UntypedExpr::createCall( countExpr->location, "lowerBound", {} );
+                auto castFirst = new ast::CastExpr( countExpr->location, untypedFirst , countExpr->type );
+                const ast::UntypedExpr * untyped = ast::UntypedExpr::createCall(
+                        countExpr->location, "Countof", { castFirst }
                 );
                 CandidateFinder finder( context, tenv );
@@ -1514 +1506 @@
                 CandidateList winners = findMinCost( finder.candidates );
                 if ( winners.size() == 0 ) {
-                        SemanticError( countExpr->expr, "Countof is not implemented for operand: " );
-                }
-                if ( winners.size() !=  1 ) {
-                        SemanticError( countExpr->expr, "Ambiguous expression in countof operand: " );
+                        SemanticError( countExpr, "Countof is not implemented: " );
+                }
+                if ( winners.size() != 1 ) {
+                        SemanticError( countExpr, "Ambiguous expression in countof: " );
                 }
                 CandidateRef & choice = winners.front();