Changes in src/AST/Expr.cpp [3e5dd913:490fb92e]

File:

• src/AST/Expr.cpp (modified) (3 diffs)

src/AST/Expr.cpp

@@ -102 +102 @@
         }
         return ret;
-}
-
-// --- VariableExpr
-
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
-}
-
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
 }
 
@@ -206 +181 @@
         assert( aggregate->result );
 
-        result = mem->get_type();
+        // Deep copy on result type avoids mutation on transitively multiply referenced object.
+        //
+        // Example, adapted from parts of builtins and bootloader:
+        //
+        // forall(dtype T)
+        // struct __Destructor {
+        //   T * object;
+        //   void (*dtor)(T *);
+        // };
+        //
+        // forall(dtype S)
+        // void foo(__Destructor(S) &d) {
+        //   if (d.dtor) {  // here
+        //   }
+        // }
+        //
+        // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve.  Let d be the
+        // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level
+        // declaration of __Destructor.  Consider the types e.result and d.type.  In the old AST, one
+        // is a clone of the other.  Ordinary new-AST use would set them up as a multiply-referenced
+        // object.
+        //
+        // e.result: PointerType
+        // .base: FunctionType
+        // .params.front(): ObjectDecl, the anonymous parameter of type T*
+        // .type: PointerType
+        // .base: TypeInstType
+        // let x = that
+        // let y = similar, except start from d.type
+        //
+        // Consider two code lines down, genericSubstitution(...).apply(result).
+        //
+        // Applying this chosen-candidate's type substitution means modifying x, substituting
+        // S for T.  This mutation should affect x and not y.
+
+        result = deepCopy(mem->get_type());
 
         // substitute aggregate generic parameters into member type
@@ -226 +236 @@
         // This is actually wrong by C, but it works with our current set-up.
         return true;
+}
+
+// --- VariableExpr
+
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        assert( var );
+        assert( var->get_type() );
+        result = shallowCopy( var->get_type() );
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+}
+
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
 }