Changes in / [ba417e2:f49b3fc]

Location:

src/AST

Files:

• Convert.cpp (modified) (1 diff)
• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (1 diff)

src/AST/Convert.cpp

@@ -2124 +2124 @@
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
-                                GET_ACCEPT_1(aggregate, Expr),
-                                ast::MemberExpr::NoOpConstructionChosen
+                                GET_ACCEPT_1(aggregate, Expr)
                         )
                 );

src/AST/Expr.cpp

@@ -158 +158 @@
         assert( aggregate->result );
 
-        // 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());
-
+        // take ownership of member type
+        result = mem->get_type();
         // substitute aggregate generic parameters into member type
         genericSubstitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
         add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
-}
-
-MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-    MemberExpr::NoOpConstruction overloadSelector )
-: Expr( loc ), member( mem ), aggregate( agg ) {
-        assert( member );
-        assert( aggregate );
-        assert( aggregate->result );
-        (void) overloadSelector;
 }
 

src/AST/Expr.hpp

@@ -358 +358 @@
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
         MUTATE_FRIEND
-
-        // Custructor overload meant only for AST conversion
-        enum NoOpConstruction { NoOpConstructionChosen };
-        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-            NoOpConstruction overloadSelector );
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };