Changes in src/AST/Expr.hpp [b3a0df6:312029a]

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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
-
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 class ConverterOldToNew;
@@ -45 +42 @@
 struct ParamEntry {
         UniqueId decl;
-        readonly<Decl> declptr;
+        ptr<Decl> declptr;
         ptr<Type> actualType;
         ptr<Type> formalType;
@@ -65 +62 @@
 class Expr : public ParseNode {
 public:
-        /*
-         * 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.
-         */
+        /// Saves space (~16 bytes) by combining ResnSlots and InferredParams
         struct InferUnion {
-                // mode is now unused
                 enum { Empty, Slots, Params } mode;
-                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;
-                        }
+                union data_t {
+                        char def;
+                        ResnSlots resnSlots;
+                        InferredParams inferParams;
+
+                        data_t() : def('\0') {}
+                        ~data_t() {}
                 } data;
 
                 /// initializes from other InferUnion
                 void init_from( const InferUnion& o ) {
-                        if (o.data.resnSlots) {
-                                data.resnSlots = new ResnSlots(*o.data.resnSlots);
-                        }
-                        if (o.data.inferParams) {
-                                data.inferParams = new InferredParams(*o.data.inferParams);
+                        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;
                         }
                 }
@@ -99 +85 @@
                 /// initializes from other InferUnion (move semantics)
                 void init_from( InferUnion&& o ) {
-                        data.resnSlots = o.data.resnSlots;
-                        data.inferParams = o.data.inferParams;
-                        o.data.resnSlots = nullptr;
-                        o.data.inferParams = nullptr;
+                        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;
+                        }
                 }
 
@@ -110 +107 @@
                 InferUnion& operator= ( const InferUnion& ) = delete;
                 InferUnion& operator= ( InferUnion&& ) = delete;
-
-                bool hasSlots() const { return data.resnSlots; }
-                bool hasParams() const { return data.inferParams; }
+                ~InferUnion() { reset(); }
 
                 ResnSlots& resnSlots() {
-                        if (!data.resnSlots) {
-                                data.resnSlots = new 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();
                         }
-                        return *data.resnSlots;
+                        assertf(false, "unreachable");
                 }
 
                 const ResnSlots& resnSlots() const {
-                        if (data.resnSlots) {
-                                return *data.resnSlots;
+                        if (mode == Slots) {
+                                return data.resnSlots;
                         }
                         assertf(false, "Mode was not already resnSlots");
@@ -130 +127 @@
 
                 InferredParams& inferParams() {
-                        if (!data.inferParams) {
-                                data.inferParams = new InferredParams();
+                        switch (mode) {
+                        case Slots: data.resnSlots.~ResnSlots(); // fallthrough
+                        case Empty: new(&data.inferParams) InferredParams{}; mode = Params; // fallthrough
+                        case Params: return data.inferParams;
                         }
-                        return *data.inferParams;
+                        assertf(false, "unreachable");
                 }
 
                 const InferredParams& inferParams() const {
-                        if (data.inferParams) {
-                                return *data.inferParams;
+                        if (mode == Params) {
+                                return data.inferParams;
                         }
                         assertf(false, "Mode was not already Params");
@@ -144 +143 @@
                 }
 
-                void set_inferParams( InferredParams * ps ) {
-                        delete data.resnSlots;
-                        data.resnSlots = nullptr;
-                        delete data.inferParams;
-                        data.inferParams = ps;
+                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;
+                        }
                 }
 
@@ -154 +161 @@
                 /// and the other is in `Params`.
                 void splice( InferUnion && o ) {
-                        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;
+                        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);
                                 }
-                                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;
-                        }
+                        } else assertf(false, "invalid mode");
                 }
         };
@@ -190 +185 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
-        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -207 +201 @@
         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:
@@ -224 +216 @@
         : Expr( loc ), func( f ), args( std::move(as) ) {}
 
-        bool get_lvalue() const final;
-
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -251 +241 @@
 };
 
-/// 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 {
@@ -300 +271 @@
 };
 
-/// 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
+/// Whether a cast existed in the program source or not
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 
@@ -328 +291 @@
         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:
@@ -340 +301 @@
 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;
@@ -389 +338 @@
         : 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:
@@ -405 +352 @@
         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;
+};
+
+/// 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
 };
 
@@ -431 +386 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
+        : Expr( loc, ty ), rep( r ), ival( i ) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -577 +532 @@
 
         CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
-        : Expr( loc ), arg1( a1 ), arg2( a2 ) {
-                this->result = a2->result;
-        }
-
-        bool get_lvalue() const final;
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -626 +577 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
+        : Expr( loc, call->result ) { assert( call ); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -654 +605 @@
         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:
@@ -711 +660 @@
 
         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 ); }
@@ -751 +698 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
-        readonly<ExprStmt> resultExpr;
-
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );