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

File:

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

src/AST/Expr.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 15 17:00:00 2019
-// Last Modified By : Andrew Beach
-// Created On       : Thr Jun 26 12:12:00 2019
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Created On       : Thr Jun 13 13:38:00 2019
+// Update Count     : 6
 //
 
@@ -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"
@@ -30 +27 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "InitTweak/InitTweak.h"   // for getFunction, getPointerBase
+#include "InitTweak/InitTweak.h"   // for 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
@@ -58 +46 @@
 }
 
-bool ApplicationExpr::get_lvalue() const {
-        if ( const DeclWithType * func = InitTweak::getFunction( this ) ) {
-                return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name );
-        }
-        return false;
-}
-
 // --- UntypedExpr
 
@@ -70 +51 @@
         assert( arg );
 
-        UntypedExpr * ret = call( loc, "*?", arg );
+        UntypedExpr * ret = new UntypedExpr{
+                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
+        };
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -88 +71 @@
 }
 
-bool UntypedExpr::get_lvalue() const {
-        std::string fname = InitTweak::getFunctionName( this );
-        return lvalueFunctionNames.count( fname );
-}
-
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
         assert( lhs && rhs );
 
-        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
+        UntypedExpr * ret = new UntypedExpr{
+                loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ rhs } }
+        };
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -128 +108 @@
 AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
         if ( arg->result ) {
-                if ( arg->get_lvalue() ) {
+                if ( arg->result->is_lvalue() ) {
                         // lvalue, retains all levels of reference, and gains a pointer inside the references
                         Type * res = addrType( arg->result );
@@ -159 +139 @@
 : 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 std::string & KeywordCastExpr::targetString() const {
-        static const std::string targetStrs[] = {
-                "coroutine", "thread", "monitor"
-        };
-        static_assert(
-                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
-                "Each KeywordCastExpr::Target should have a corresponding string representation"
-        );
-        return targetStrs[(unsigned long)target];
-}
-
-// --- UntypedMemberExpr
-
-bool UntypedMemberExpr::get_lvalue() const {
-        return aggregate->get_lvalue();
+const char * KeywordCastExpr::targetString() const {
+        return AggregateDecl::aggrString( target );
 }
 
@@ -191 +153 @@
         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 );
@@ -234 +161 @@
 }
 
-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;
-}
-
 // --- VariableExpr
 
@@ -257 +170 @@
         assert( var );
         assert( var->get_type() );
-        auto r = shallowCopy( var->get_type() );
-        r->qualifiers |= CV::Lvalue;
-        result = r;
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
+        result = var->get_type();
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -350 +257 @@
         const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
 : 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
@@ -379 +279 @@
 }
 
-bool CompoundLiteralExpr::get_lvalue() const {
-        return true;
-}
-
 // --- TupleExpr
 
@@ -398 +294 @@
         result = type->types[ index ];
         add_qualifiers( result, CV::Lvalue );
-}
-
-bool TupleIndexExpr::get_lvalue() const {
-        return tuple->get_lvalue();
 }