Changeset b6f2e7ab for src/AST

Timestamp:

Sep 9, 2024, 5:15:32 PM (14 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/AST

Files:

• Expr.cpp (modified) (2 diffs)
• Expr.hpp (modified) (2 diffs)
• Pass.impl.hpp (modified) (2 diffs)
• Print.cpp (modified) (2 diffs)
• Util.cpp (modified) (2 diffs)

src/AST/Expr.cpp

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

src/AST/Expr.hpp

@@ -480 +480 @@
 class SizeofExpr final : public Expr {
 public:
+        ptr<Type> type;
+
+        SizeofExpr( const CodeLocation & loc, const Type * t );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+class CountExpr final : public Expr {
+public:
         ptr<Expr> expr;
         ptr<Type> type;
 
-        SizeofExpr( const CodeLocation & loc, const Expr * e );
-        SizeofExpr( const CodeLocation & loc, const Type * t );
-        // deliberately no disambiguating overload for nullptr_t
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
-        MUTATE_FRIEND
-};
-
-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 );
@@ -510 +507 @@
 class AlignofExpr final : public Expr {
 public:
-        ptr<Expr> expr;
         ptr<Type> type;
 
-        AlignofExpr( const CodeLocation & loc, const Expr * e );
         AlignofExpr( const CodeLocation & loc, const Type * t );
-        // deliberately no disambiguating overload for nullptr_t
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Pass.impl.hpp

@@ -1319 +1319 @@
                         maybe_accept( node, &SizeofExpr::result );
                 }
-                if ( node->type ) {
-                        maybe_accept( node, &SizeofExpr::type );
-                } else {
-                        maybe_accept( node, &SizeofExpr::expr );
-                }
+                maybe_accept( node, &SizeofExpr::type );
         }
 
@@ -1359 +1355 @@
                         maybe_accept( node, &AlignofExpr::result );
                 }
-                if ( node->type ) {
-                        maybe_accept( node, &AlignofExpr::type );
-                } else {
-                        maybe_accept( node, &AlignofExpr::expr );
-                }
+                maybe_accept( node, &AlignofExpr::type );
         }
 

src/AST/Print.cpp

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

src/AST/Util.cpp

@@ -104 +104 @@
         }
         assertf( false, "Member not found." );
-}
-
-template<typename node_t>
-void oneOfExprOrType( const node_t * node ) {
-        if ( node->expr ) {
-                assertf( node->expr && !node->type, "Exactly one of expr or type should be set." );
-        } else {
-                assertf( !node->expr && node->type, "Exactly one of expr or type should be set." );
-        }
 }
 
@@ -163 +154 @@
         void previsit( const SizeofExpr * node ) {
                 previsit( (const ParseNode *)node );
-                oneOfExprOrType( node );
         }
 
         void previsit( const AlignofExpr * node ) {
                 previsit( (const ParseNode *)node );
-                oneOfExprOrType( node );
         }