Changeset e67a82d for src/AST/Expr.hpp

Timestamp:

Aug 20, 2020, 11:48:15 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

d685cb0

Parents:

67ca73e (diff), 013b028 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

fix conflicts

File:

• src/AST/Expr.hpp (modified) (18 diffs)

src/AST/Expr.hpp

@@ -31 +31 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+
 
 class ConverterOldToNew;
@@ -42 +45 @@
 struct ParamEntry {
         UniqueId decl;
-        ptr<Decl> declptr;
+        readonly<Decl> declptr;
         ptr<Type> actualType;
         ptr<Type> formalType;
@@ -62 +65 @@
 class Expr : public ParseNode {
 public:
-        /// Saves space (~16 bytes) by combining ResnSlots and InferredParams
+        /*
+         * NOTE: the union approach is incorrect until the case of
+         * partial resolution in InferMatcher is eliminated.
+         * it is reverted to allow unresolved and resolved parameters
+         * to coexist in an expression node.
+         */
         struct InferUnion {
+                // mode is now unused
                 enum { Empty, Slots, Params } mode;
-                union data_t {
-                        char def;
-                        ResnSlots resnSlots;
-                        InferredParams inferParams;
-
-                        data_t() : def('\0') {}
-                        ~data_t() {}
+                struct data_t {
+                        // char def;
+                        ResnSlots * resnSlots;
+                        InferredParams * inferParams;
+
+                        data_t(): resnSlots(nullptr), inferParams(nullptr) {}
+                        data_t(const data_t &other) = delete;
+                        ~data_t() {
+                                delete resnSlots;
+                                delete inferParams;
+                        }
                 } data;
 
                 /// initializes from other InferUnion
                 void init_from( const InferUnion& o ) {
-                        switch ( o.mode ) {
-                        case Empty:  return;
-                        case Slots:  new(&data.resnSlots) ResnSlots{ o.data.resnSlots }; return;
-                        case Params: new(&data.inferParams) InferredParams{ o.data.inferParams }; return;
+                        if (o.data.resnSlots) {
+                                data.resnSlots = new ResnSlots(*o.data.resnSlots);
+                        }
+                        if (o.data.inferParams) {
+                                data.inferParams = new InferredParams(*o.data.inferParams);
                         }
                 }
@@ -85 +99 @@
                 /// initializes from other InferUnion (move semantics)
                 void init_from( InferUnion&& o ) {
-                        switch ( o.mode ) {
-                        case Empty:  return;
-                        case Slots:  new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return;
-                        case Params:
-                                new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return;
-                        }
-                }
-
-                /// clears variant fields
-                void reset() {
-                        switch( mode ) {
-                        case Empty:  return;
-                        case Slots:  data.resnSlots.~ResnSlots(); return;
-                        case Params: data.inferParams.~InferredParams(); return;
-                        }
+                        data.resnSlots = o.data.resnSlots;
+                        data.inferParams = o.data.inferParams;
+                        o.data.resnSlots = nullptr;
+                        o.data.inferParams = nullptr;
                 }
 
@@ -107 +110 @@
                 InferUnion& operator= ( const InferUnion& ) = delete;
                 InferUnion& operator= ( InferUnion&& ) = delete;
-                ~InferUnion() { reset(); }
+
+                bool hasSlots() const { return data.resnSlots; }
 
                 ResnSlots& resnSlots() {
-                        switch (mode) {
-                        case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough
-                        case Slots: return data.resnSlots;
-                        case Params: assertf(false, "Cannot return to resnSlots from Params"); abort();
+                        if (!data.resnSlots) {
+                                data.resnSlots = new ResnSlots();
                         }
-                        assertf(false, "unreachable");
+                        return *data.resnSlots;
                 }
 
                 const ResnSlots& resnSlots() const {
-                        if (mode == Slots) {
-                                return data.resnSlots;
+                        if (data.resnSlots) {
+                                return *data.resnSlots;
                         }
                         assertf(false, "Mode was not already resnSlots");
@@ -127 +129 @@
 
                 InferredParams& inferParams() {
-                        switch (mode) {
-                        case Slots: data.resnSlots.~ResnSlots(); // fallthrough
-                        case Empty: new(&data.inferParams) InferredParams{}; mode = Params; // fallthrough
-                        case Params: return data.inferParams;
+                        if (!data.inferParams) {
+                                data.inferParams = new InferredParams();
                         }
-                        assertf(false, "unreachable");
+                        return *data.inferParams;
                 }
 
                 const InferredParams& inferParams() const {
-                        if (mode == Params) {
-                                return data.inferParams;
+                        if (data.inferParams) {
+                                return *data.inferParams;
                         }
                         assertf(false, "Mode was not already Params");
@@ -143 +143 @@
                 }
 
-                void set_inferParams( InferredParams && ps ) {
-                        switch(mode) {
-                        case Slots:
-                                data.resnSlots.~ResnSlots();
-                                // fallthrough
-                        case Empty:
-                                new(&data.inferParams) InferredParams{ std::move( ps ) };
-                                mode = Params;
-                                break;
-                        case Params:
-                                data.inferParams = std::move( ps );
-                                break;
-                        }
+                void set_inferParams( InferredParams * ps ) {
+                        delete data.resnSlots;
+                        data.resnSlots = nullptr;
+                        delete data.inferParams;
+                        data.inferParams = ps;
                 }
 
@@ -161 +153 @@
                 /// and the other is in `Params`.
                 void splice( InferUnion && o ) {
-                        if ( o.mode == Empty ) return;
-                        if ( mode == Empty ) { init_from( o ); return; }
-                        assert( mode == o.mode && "attempt to splice incompatible InferUnion" );
-
-                        if ( mode == Slots ){
-                                data.resnSlots.insert(
-                                        data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() );
-                        } else if ( mode == Params ) {
-                                for ( const auto & p : o.data.inferParams ) {
-                                        data.inferParams[p.first] = std::move(p.second);
+                        if (o.data.resnSlots) {
+                                if (data.resnSlots) {
+                                        data.resnSlots->insert(
+                                                data.resnSlots->end(), o.data.resnSlots->begin(), o.data.resnSlots->end() );
+                                        delete o.data.resnSlots;
                                 }
-                        } else assertf(false, "invalid mode");
+                                else {
+                                        data.resnSlots = o.data.resnSlots;
+                                }
+                                o.data.resnSlots = nullptr;
+                        }
+
+                        if (o.data.inferParams) {
+                                if (data.inferParams) {
+                                        for ( const auto & p : *o.data.inferParams ) {
+                                                (*data.inferParams)[p.first] = std::move(p.second);
+                                        }
+                                        delete o.data.inferParams;
+                                }
+                                else {
+                                        data.inferParams = o.data.inferParams;
+                                }
+                                o.data.inferParams = nullptr;
+                        }
                 }
         };
@@ -185 +189 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
+        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -201 +206 @@
         ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -215 +222 @@
         UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
         : Expr( loc ), func( f ), args( std::move(as) ) {}
+
+        bool get_lvalue() const final;
 
         /// Creates a new dereference expression
@@ -291 +300 @@
         CastExpr( const Expr * a ) : CastExpr( a->location, a, GeneratedCast ) {}
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -338 +349 @@
         : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -352 +365 @@
         MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         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;
 };
 
@@ -365 +387 @@
         VariableExpr( const CodeLocation & loc );
         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
 
         /// generates a function pointer for a given function
@@ -532 +556 @@
 
         CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
-        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {
+                this->result = a2->result;
+        }
+
+        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -605 +633 @@
         CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -660 +690 @@
 
         TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i );
+
+        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }