Changes in src/AST/Expr.cpp [312029a:d5631b3]

File:

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

src/AST/Expr.cpp

@@ -20 +20 @@
 #include <vector>
 
+#include "Copy.hpp"                // for shallowCopy
+#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
+#include "LinkageSpec.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
@@ -27 +30 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "InitTweak/InitTweak.h"   // for getFunction, getPointerBase
 #include "ResolvExpr/typeops.h"    // for extractResultType
 #include "Tuples/Tuples.h"         // for makeTupleType
 
 namespace ast {
+
+namespace {
+        std::set<std::string> const lvalueFunctionNames = {"*?", "?[?]"};
+}
+
+// --- Expr
+bool Expr::get_lvalue() const {
+        return false;
+}
 
 // --- ApplicationExpr
@@ -46 +58 @@
 }
 
+bool ApplicationExpr::get_lvalue() const {
+        if ( const DeclWithType * func = InitTweak::getFunction( this ) ) {
+                return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name );
+        }
+        return false;
+}
+
 // --- UntypedExpr
 
@@ -51 +70 @@
         assert( arg );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
-        };
+        UntypedExpr * ret = call( loc, "*?", arg );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -65 +82 @@
                         // base type
                         ret->result = base;
-                        add_qualifiers( ret->result, CV::Lvalue );
                 }
         }
         return ret;
+}
+
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
 }
 
@@ -74 +95 @@
         assert( lhs && rhs );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ rhs } }
-        };
+        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -83 +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;
 }
 
@@ -108 +152 @@
 AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
         if ( arg->result ) {
-                if ( arg->result->is_lvalue() ) {
+                if ( arg->get_lvalue() ) {
                         // lvalue, retains all levels of reference, and gains a pointer inside the references
                         Type * res = addrType( arg->result );
-                        res->set_lvalue( false ); // result of & is never an lvalue
                         result = res;
                 } else {
@@ -118 +161 @@
                                         dynamic_cast< const ReferenceType * >( arg->result.get() ) ) {
                                 Type * res = addrType( refType->base );
-                                res->set_lvalue( false ); // result of & is never an lvalue
                                 result = res;
                         } else {
@@ -139 +181 @@
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
 
+bool CastExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return arg->get_lvalue();
+}
+
 // --- KeywordCastExpr
 
 const char * KeywordCastExpr::targetString() const {
         return AggregateDecl::aggrString( target );
+}
+
+// --- UntypedMemberExpr
+
+bool UntypedMemberExpr::get_lvalue() const {
+        return aggregate->get_lvalue();
 }
 
@@ -153 +206 @@
         assert( aggregate->result );
 
-        // take ownership of member type
-        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
         genericSubstitution( aggregate->result ).apply( result );
-        // ensure lvalue and appropriate restrictions from aggregate type
-        add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
-}
-
-// --- 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 = var->get_type();
-        add_qualifiers( result, CV::Lvalue );
-}
-
-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;
+        // ensure appropriate restrictions from aggregate type
+        add_qualifiers( result, aggregate->result->qualifiers );
+}
+
+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;
+}
+
+bool MemberExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return true;
 }
 
@@ -258 +339 @@
 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
 
+// --- CommaExpr
+bool CommaExpr::get_lvalue() const {
+        // This is wrong by C, but the current implementation uses it.
+        // (ex: Specialize, Lvalue and Box)
+        return arg2->get_lvalue();
+}
+
 // --- ConstructorExpr
 
@@ -276 +364 @@
         assert( t && i );
         result = t;
-        add_qualifiers( result, CV::Lvalue );
+}
+
+bool CompoundLiteralExpr::get_lvalue() const {
+        return true;
 }
 
@@ -293 +384 @@
         // like MemberExpr, TupleIndexExpr is always an lvalue
         result = type->types[ index ];
-        add_qualifiers( result, CV::Lvalue );
+}
+
+bool TupleIndexExpr::get_lvalue() const {
+        return tuple->get_lvalue();
 }