Changes in / [54cd1a51:4d5c5b6a]

Files:

• src/AST/Expr.cpp (modified) (3 diffs)
• src/AST/Expr.hpp (modified) (3 diffs)
• src/AST/Util.cpp (modified) (1 diff)
• src/AST/Util.hpp (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• src/main.cpp (modified) (1 diff)
• tests/.expect/alloc-ERROR.arm64.txt (modified) (1 diff)
• tests/.expect/alloc-ERROR.x64.txt (modified) (1 diff)
• tests/.expect/alloc-ERROR.x86.txt (modified) (1 diff)

src/AST/Expr.cpp

@@ -26 +26 @@
 #include "Stmt.hpp"
 #include "Type.hpp"
+#include "Util.hpp"                // for TranslationDeps
 #include "TypeSubstitution.hpp"
 #include "Common/Utility.hpp"
@@ -280 +281 @@
 // --- SizeofExpr
 
-SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * type )
-: SizeofExpr( loc, type, nullptr ) {}
-
-SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * type, const Type * result )
-: Expr( loc, result ), type( type ) {}
+SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
+: Expr( loc, ast::TranslationDeps::getSizeType() ), type( t ) {}
 
 // --- AlignofExpr
 
-AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * type )
-: AlignofExpr( loc, type, nullptr ) {}
-
-AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * type, const Type * result )
-: Expr( loc, result ), type( type ) {}
+AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
+: Expr( loc, ast::TranslationDeps::getSizeType() ), type( t ) {}
 
 // --- CountofExpr
 
 CountofExpr::CountofExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc ), type( t ) {}
+: Expr( loc, ast::TranslationDeps::getSizeType() ), type( t ) {}
 
 // --- OffsetofExpr
 
 OffsetofExpr::OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem )
-: OffsetofExpr( loc, ty, mem, nullptr ) {}
-
-OffsetofExpr::OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem, const Type * res )
-: Expr( loc, res ), type( ty ), member( mem ) {
+: Expr( loc, ast::TranslationDeps::getSizeType() ), type( ty ), member( mem ) {
         assert( type );
         assert( member );
@@ -313 +305 @@
 
 OffsetPackExpr::OffsetPackExpr( const CodeLocation & loc, const StructInstType * ty )
-: Expr( loc ), type( ty ) {
+: Expr( loc, new ArrayType{
+        ast::TranslationDeps::getSizeType(), nullptr, FixedLen, DynamicDim }
+), type( ty ) {
         assert( type );
 }

src/AST/Expr.hpp

@@ -483 +483 @@
 
         SizeofExpr( const CodeLocation & loc, const Type * t );
-        SizeofExpr( const CodeLocation & loc, const Type * t, const Type * r );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -497 +496 @@
 
         AlignofExpr( const CodeLocation & loc, const Type * t );
-        AlignofExpr( const CodeLocation & loc, const Type * t, const Type * r );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -540 +538 @@
 
         OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem );
-        OffsetofExpr( const CodeLocation & loc, const Type * ty, const DeclWithType * mem, const Type * res );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Util.cpp

@@ -384 +384 @@
 }
 
+namespace {
+        const TranslationUnit * transUnit = 0;
+}
+
+void TranslationDeps::evolve( TranslationUnit & u ) {
+        transUnit = &u;
+}
+
+const ast::Type * TranslationDeps::getSizeType() {
+        static const ast::Type * zd_abstract = new TypeInstType{ "size_t", TypeDecl::Kind::Dtype };
+        static const ast::Type * ld_concrete = new BasicType( BasicKind::LongUnsignedInt );
+        if ( ! transUnit ) {
+                // early state
+                // as if `size_t` in program text were freshly parsed
+                return zd_abstract;
+        } else if ( transUnit->global.sizeType ) {
+                // late state, normal run
+                // whatever size_t was defined as
+                return transUnit->global.sizeType;
+        } else {
+                // late state, no prelude (-n)
+                // placeholder: cfa-cpp is being used experimentally, stay out of the way
+                return ld_concrete;
+        }
+}
+
+
 } // namespace ast

src/AST/Util.hpp

@@ -26 +26 @@
 void checkInvariants( TranslationUnit & );
 
+/// Maintains an AST-module state for contextual information needed in
+/// ast::* implementations, notably constructors:
+///    early: while parsing, use bootstrap versions
+///    late: once a whole TranslationUnit exists, use its answers
+/// When the program is in the later state, ast::* construcors effectively get
+/// the benefit of WithTranslationUnit, without having to pass them one.
+class TranslationDeps {
+
+    TranslationDeps() = delete;
+
+    friend class SizeofExpr;
+    friend class AlignofExpr;
+    friend class CountofExpr;
+    friend class OffsetofExpr;
+    friend class OffsetPackExpr;
+
+    /// Appropriate return type for built-in expressions that report on sizes
+    static const Type * getSizeType();
+
+  public:
+    /// Transition from early to late states
+    static void evolve( TranslationUnit & );
+};
+
 }

src/ResolvExpr/CandidateFinder.cpp

@@ -1486 +1486 @@
 
         void Finder::postvisit( const ast::SizeofExpr * sizeofExpr ) {
-                const ast::Type * type = resolveTypeof( sizeofExpr->type, context );
-                const ast::Type * sizeType = context.global.sizeType.get();
                 addCandidate(
-                        new ast::SizeofExpr( sizeofExpr->location, type, sizeType ),
-                        tenv );
-        }
-
-        void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
-                const ast::Type * type = resolveTypeof( alignofExpr->type, context );
-                const ast::Type * sizeType = context.global.sizeType.get();
-                addCandidate(
-                        new ast::AlignofExpr( alignofExpr->location, type, sizeType ),
+                        new ast::SizeofExpr{
+                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
                         tenv );
         }
@@ -1525 +1516 @@
         }
 
+        void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
+                addCandidate(
+                        new ast::AlignofExpr{
+                                alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
+                        tenv );
+        }
+
         void Finder::postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
                 const ast::BaseInstType * aggInst;
@@ -1531 +1529 @@
                 else return;
 
-                const ast::Type * sizeType = context.global.sizeType.get();
                 for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
                         auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
                         addCandidate(
-                                new ast::OffsetofExpr( offsetofExpr->location, aggInst, dwt, sizeType ), tenv );
+                                new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
                 }
         }

src/main.cpp

@@ -199 +199 @@
                 Stats::Time::StopBlock();
 
+                ast::TranslationDeps::evolve( transUnit );
+
                 PASS( "Hoist Type Decls", Validate::hoistTypeDecls, transUnit );
 

tests/.expect/alloc-ERROR.arm64.txt

@@ -16 +16 @@
           Name: stp
 
+      ... with resolved type:
+        unsigned long int
 
 

tests/.expect/alloc-ERROR.x64.txt

@@ -16 +16 @@
           Name: stp
 
+      ... with resolved type:
+        unsigned long int
 
 

tests/.expect/alloc-ERROR.x86.txt

@@ -16 +16 @@
           Name: stp
 
+      ... with resolved type:
+        unsigned int