Changeset 58fe85a for src/AST/Expr.hpp

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (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:

Merge branch 'master' into park_unpark

File:

• src/AST/Expr.hpp (modified) (23 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; }
+                bool hasParams() const { return data.inferParams; }
 
                 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 +130 @@
 
                 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 +144 @@
                 }
 
-                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 +154 @@
                 /// 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 +190 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
+        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -201 +207 @@
         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:
@@ -216 +224 @@
         : Expr( loc ), func( f ), args( std::move(as) ) {}
 
+        bool get_lvalue() const final;
+
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -241 +251 @@
 };
 
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Address-of expression `&e`
 class AddressExpr final : public Expr {
@@ -271 +300 @@
 };
 
-/// Whether a cast existed in the program source or not
+/// Inidicates whether the cast is introduced by the CFA type system.
+/// GeneratedCast for casts that the resolver introduces to force a return type
+/// ExplicitCast for casts from user code
+/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
+/// example
+///   int * p;     // declaration
+///   (float *) p; // use, with subject cast
+/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
+/// subject cast being ExplicitCast means someone in charge wants it that way
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 
@@ -291 +328 @@
         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:
@@ -301 +340 @@
 public:
         ptr<Expr> arg;
+        struct Concrete {
+                std::string field;
+                std::string getter;
+
+                Concrete() = default;
+                Concrete(const Concrete &) = default;
+        };
         ast::AggregateDecl::Aggregate target;
+        Concrete concrete_target;
+
 
         KeywordCastExpr( const CodeLocation & loc, const Expr * a, ast::AggregateDecl::Aggregate t )
         : Expr( loc ), arg( a ), target( t ) {}
 
+        KeywordCastExpr( const CodeLocation & loc, const Expr * a, ast::AggregateDecl::Aggregate t, const Concrete & ct )
+        : Expr( loc ), arg( a ), target( t ), concrete_target( ct ) {}
+
         /// Get a name for the target type
         const char * targetString() const;
@@ -338 +389 @@
         : 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 +405 @@
         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
-};
-
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *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;
 };
 
@@ -386 +431 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -532 +577 @@
 
         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 ); }
@@ -577 +626 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -605 +654 @@
         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 +711 @@
 
         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 ); }
@@ -698 +751 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
+        readonly<ExprStmt> resultExpr;
+
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );