Changes in src/AST/Convert.cpp [37cdd97:07d867b]

File:

• src/AST/Convert.cpp (modified) (7 diffs)

src/AST/Convert.cpp

@@ -20 +20 @@
 
 #include "AST/Attribute.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Expr.hpp"
@@ -587 +588 @@
                 assert( tgtResnSlots.empty() );
 
-                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
+                if ( srcInferred.data.inferParams ) {
                         const ast::InferredParams &srcParams = srcInferred.inferParams();
                         for (auto & srcParam : srcParams) {
@@ -593 +594 @@
                                         srcParam.second.decl,
                                         get<Declaration>().accept1(srcParam.second.declptr),
-                                        get<Type>().accept1(srcParam.second.actualType),
-                                        get<Type>().accept1(srcParam.second.formalType),
-                                        get<Expression>().accept1(srcParam.second.expr)
+                                        get<Type>().accept1(srcParam.second.actualType)->clone(),
+                                        get<Type>().accept1(srcParam.second.formalType)->clone(),
+                                        get<Expression>().accept1(srcParam.second.expr)->clone()
                                 ));
                                 assert(res.second);
                         }
-                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
+                }
+                if ( srcInferred.data.resnSlots ) {
                         const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
                         for (auto srcSlot : srcSlots) {
@@ -620 +622 @@
 
                 tgt->result = get<Type>().accept1(src->result);
+                // Unconditionally use a clone of the result type.
+                // We know this will leak some objects: much of the immediate conversion result.
+                // In some cases, using the conversion result directly gives unintended object sharing.
+                // A parameter (ObjectDecl, a child of a FunctionType) is shared by the weak-ref cache.
+                // But tgt->result must be fully owned privately by tgt.
+                // Applying these conservative copies here means
+                // - weak references point at the declaration's copy, not these expr.result copies (good)
+                // - we copy more objects than really needed (bad, tolerated)
+                if (tgt->result) {
+                        tgt->result = tgt->result->clone();
+                }
                 return visitBaseExpr_skipResultType(src, tgt);
         }
@@ -979 +992 @@
 
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
+                auto stmts = node->stmts;
+                // disable sharing between multiple StmtExprs explicitly.
+                if (inCache(stmts)) {
+                        stmts = ast::deepCopy(stmts.get());
+                }
                 auto rslt = new StmtExpr(
-                        get<CompoundStmt>().accept1(node->stmts)
+                        get<CompoundStmt>().accept1(stmts)
                 );
 
@@ -1986 +2004 @@
 
                 assert( oldInferParams.empty() || oldResnSlots.empty() );
-                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
+                // assert( newInferred.mode == ast::Expr::InferUnion::Empty );
 
                 if ( !oldInferParams.empty() ) {
@@ -2117 +2135 @@
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
-                                GET_ACCEPT_1(aggregate, Expr)
+                                GET_ACCEPT_1(aggregate, Expr),
+                                ast::MemberExpr::NoOpConstructionChosen
                         )
                 );