Ticket #280: compound-literal-expr.diff

libcfa/prelude/builtins.c

@@ -27 +27 @@
 // Defined destructor in the case that non-generated code wants to use __Destructor.
 forall( T & )
 inline void ^?{}( __Destructor(T) & x ) {
-        if ( x.object && x.dtor ) {
-                x.dtor( x.object );
-        }
+        // MAKE SURE TO CHANGE THIS BACK!!!
+//      if ( x.object && x.dtor ) {
+//              x.dtor( x.object );
+//      }
 }
 
 // Easy interface into __Destructor's destructor for easy codegen purposes.

src/AST/Expr.cpp

@@ -342 +342 @@
 // --- CompoundLiteralExpr
 
 CompoundLiteralExpr::CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i )
-: Expr( loc ), init( i ) {
+: Expr( loc ), init( i ), decl( nullptr ) {
         assert( t && i );
         result = t;
 }
 
+CompoundLiteralExpr::CompoundLiteralExpr( const CodeLocation & loc, const ObjectDecl * d )
+: Expr( loc ), init( nullptr ), decl( d ) {
+        assert( d );
+        result = deepCopy( d->type );
+}
+
 bool CompoundLiteralExpr::get_lvalue() const {
         return true;
 }

src/AST/Expr.hpp

@@ -688 +688 @@
 class CompoundLiteralExpr final : public Expr {
 public:
         ptr<Init> init;
+        // TODO: Reduce the CompoundLiteralExpr to an ObjectDecl but don't
+        // hoist it yet. (Temp fix for testing.)
+        ptr<ObjectDecl> decl;
 
         CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
+        CompoundLiteralExpr( const CodeLocation & loc, const ObjectDecl * d );
 
         bool get_lvalue() const final;
 

src/AST/Pass.impl.hpp

@@ -1583 +1583 @@
                         maybe_accept( node, &CompoundLiteralExpr::result );
                 }
                 maybe_accept( node, &CompoundLiteralExpr::init );
+                maybe_accept( node, &CompoundLiteralExpr::decl );
         }
 
         VISIT_END( Expr, node );
@@ -2120 +2121 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &ConstructorInit::ctor );
                 maybe_accept( node, &ConstructorInit::dtor );
-                maybe_accept( node, &ConstructorInit::init );
         }
 
         VISIT_END( Init, node );

src/AST/Print.cpp

@@ -1342 +1342 @@
                 safe_print( node->result );
                 os << indent;
                 safe_print( node->init );
+                os << indent;
+                safe_print( node->decl );
                 --indent;
                 postprint( node );
 

src/CodeGen/CodeGenerator.cpp

@@ -904 +904 @@
 }
 
 void CodeGenerator::postvisit( ast::CompoundLiteralExpr const * expr ) {
-        //assert( expr->result && dynamic_cast<ast::ListInit const *>( expr->init ) );
-        assert( expr->result && expr->init.as<ast::ListInit>() );
+        assert( expr->result );
         output << "(" << genType( expr->result, "", options ) << ")";
-        expr->init->accept( *visitor );
+        if ( expr->init ) {
+                //assert( expr->init.as<ast::ListInit>() );
+                expr->init->accept( *visitor );
+        } else {
+                assert( expr->decl );
+                //assert( expr->decl->init.as<ast::ListInit>() );
+                expr->decl->init->accept( *visitor );
+        }
 }
 
 void CodeGenerator::postvisit( ast::UniqueExpr const * expr ) {

src/ResolvExpr/CandidateFinder.cpp

@@ -44 +44 @@
 #include "AST/Print.hpp"
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "Common/UniqueName.hpp"
 #include "Common/Utility.hpp"       // for move, copy
 #include "SymTab/Mangler.hpp"
 #include "Tuples/Tuples.hpp"        // for handleTupleAssignment
+#include "InitTweak/GenInit.hpp"    // for genCtorInit
 #include "InitTweak/InitTweak.hpp"  // for getPointerBase
 
 #include "Common/Stats/Counter.hpp"
@@ -688 +690 @@
                 void postvisit( const ast::CommaExpr * commaExpr );
                 void postvisit( const ast::ImplicitCopyCtorExpr * ctorExpr );
                 void postvisit( const ast::ConstructorExpr * ctorExpr );
+                void postvisit( const ast::CompoundLiteralExpr * compoundExpr );
                 void postvisit( const ast::RangeExpr * rangeExpr );
                 void postvisit( const ast::UntypedTupleExpr * tupleExpr );
                 void postvisit( const ast::TupleExpr * tupleExpr );
@@ -1049 +1052 @@
                 // Find function matches
                 CandidateList found;
                 SemanticErrorException errors;
-                
                 for ( CandidateRef & func : funcFinder ) {
                         try {
                                 PRINT(
@@ -1669 +1671 @@
                 }
         }
 
+        void Finder::postvisit( const ast::CompoundLiteralExpr * expr ) {
+                // We are getting recursive cases. I don't know if this is a not
+                // supposed to happen (as a no-op) or not.
+                if ( !expr->init ) {
+                        assert( expr->decl );
+                        addCandidate( ast::deepCopy( expr ), tenv );
+                        return;
+                }
+
+                // These names should never make it to code generation, but it does
+                // so for now they must be uniquely named.
+                static UniqueName compLit("_compLitExpr");
+                const CodeLocation& location = expr->location;
+                //const ast::Type * type = expr->result;
+
+                ast::ptr<ast::ObjectDecl> decl0 = new ast::ObjectDecl( location,
+                        compLit.newName(),
+                        expr->result,
+                        ast::deepCopy( expr->init )
+                );
+
+                ast::ptr<ast::Decl> newDecl = ResolvExpr::resolveSingleDecl(
+                        decl0.get(), context
+                );
+
+                ast::ObjectDecl const * objectDecl = newDecl.strict_as<ast::ObjectDecl>();
+
+                addCandidate(
+                        new ast::CompoundLiteralExpr( location, objectDecl ),
+                        tenv );
+
+                // Should has been resolved.
+                // This has all three fields set, ctor or init should be cleared.
+        //      ast::ptr<ast::ConstructorInit> init =
+        //      InitTweak::genCtorInit( location, decl );
+
+                // genCtorInit produces unresolved code.
+        //      ast::ptr<ast::Init> init2 = resolveCtorInit( init, context );
+
+        //      addCandidate(
+        //              new ast::CompoundLiteralExpr( location, objectDecl ),
+        //              tenv );
+        }
+
         void Finder::postvisit( const ast::RangeExpr * rangeExpr ) {
                 // resolve low and high, accept candidates where low and high types unify
                 CandidateFinder finder1( context, tenv );

src/ResolvExpr/Resolver.cpp

@@ -439 +439 @@
         ast::Pass< Resolver >::run( translationUnit, translationUnit.global );
 }
 
+// Does this need to return a ptr?
+ast::ptr< ast::Decl > resolveSingleDecl(
+            const ast::Decl * decl, const ResolveContext & context ) {
+        assert( decl );
+        ast::Pass< Resolver > resolver( context );
+        return decl->accept( resolver );
+}
+
+ast::ptr< ast::Init > resolveInit(
+                const ast::Init * init, const ResolveContext & context ) {
+        assert( init );
+        ast::Pass< Resolver > resolver( context );
+        return init->accept( resolver );
+}
+
 ast::ptr< ast::Init > resolveCtorInit(
         const ast::ConstructorInit * ctorInit, const ResolveContext & context
 ) {

src/ResolvExpr/Resolver.hpp

@@ -43 +43 @@
 void resolve( ast::TranslationUnit& translationUnit );
 /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
 const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr );
+/// Resolve the declaration (and all its declarations) in the given context.
+ast::ptr< ast::Decl > resolveSingleDecl(
+        const ast::Decl * decl, const ResolveContext & );
 /// Find the expression candidate that is the unique
 /// best match for `untyped` in a `void` context.
 ast::ptr< ast::Expr > resolveInVoidContext(
@@ -54 +57 @@
 ast::ptr< ast::Expr > findVoidExpression(
         const ast::Expr * untyped, const ResolveContext & );
 /// Resolves a constructor init expression
+ast::ptr< ast::Init > resolveInit(
+        const ast::Init * init, const ResolveContext & context );
 ast::ptr< ast::Init > resolveCtorInit(
         const ast::ConstructorInit * ctorInit, const ResolveContext & context );
 /// Resolves a statement expression

src/Validate/CompoundLiteral.cpp

@@ -30 +30 @@
         ast::Storage::Classes storageClasses;
 
         void previsit( const ast::ObjectDecl * decl );
+        const ast::CompoundLiteralExpr * previsit( const ast::CompoundLiteralExpr * );
         const ast::Expr * postvisit( const ast::CompoundLiteralExpr * expr );
 };
 
@@ -37 +38 @@
         storageClasses = decl->storage;
 }
 
+const ast::CompoundLiteralExpr * CompoundLiteral::previsit( const ast::CompoundLiteralExpr * expr ) {
+        if ( expr->decl ) {
+                auto mut = ast::mutate( expr );
+                mut->decl.get_and_mutate()->storage = storageClasses;
+                return mut;
+        }
+        return expr;
+}
+
 const ast::Expr * CompoundLiteral::postvisit(
                 const ast::CompoundLiteralExpr * expr ) {
         static UniqueName litName( "_compLit" );
@@ -44 +54 @@
         // Transform: [storageClasses] ... (struct S){...} ...
         // Into:      [storageClasses] struct S _compLit = {...};
         //                             ... _compLit ...
-        ast::ObjectDecl * temp = new ast::ObjectDecl(
-                expr->location,
-                litName.newName(),
-                expr->result,
-                expr->init,
-                storageClasses
+        ast::ObjectDecl * temp;
+        if ( expr->decl ) {
+                temp = ast::mutate( expr->decl.get() );
+                // I tried doing renaming, but that might require remangling.
+                temp->name = litName.newName();
+                temp->mangleName = "";
+        } else if ( expr->init ) {
+                temp = new ast::ObjectDecl(
+                        expr->location,
+                        litName.newName(),
+                        expr->result,
+                        expr->init,
+                        storageClasses
                 );
+        } else {
+                assert( false );
+        }
         // FIXME: A resolution of #280 could make the unused attribute unnecessary here
         //     (let test nowarn/unused decide)
         temp->attributes.push_back( new ast::Attribute( "unused" ) );

src/main.cpp

@@ -233 +233 @@
                 PASS( "Implement Virtual Destructors", Virtual::implementVirtDtors, transUnit );
                 PASS( "Implement Mutex", Concurrency::implementMutex, transUnit );
                 PASS( "Implement Thread Start", Concurrency::implementThreadStarter, transUnit );
-                PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
                 PASS( "Set Length From Initializer", Validate::setLengthFromInitializer, transUnit );
                 PASS( "Find Global Decls", Validate::findGlobalDecls, transUnit );
 
@@ -273 +272 @@
 
                 PASS( "Resolve", ResolvExpr::resolve, transUnit );
                 DUMP( exprp, transUnit );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals, transUnit );
                 PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() ); // Here
                 PASS( "Erase With", ResolvExpr::eraseWith, transUnit );