Changeset 9b4f329

Timestamp:

May 16, 2019, 6:46:51 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

246c245

Parents:

f3cc5b6

Message:

Finished porting AST::Expr subclasses

Location:

src

Files:

• AST/Expr.cpp (modified) (3 diffs)
• AST/Expr.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (2 diffs)
• AST/Type.hpp (modified) (1 diff)
• AST/porting.md (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (5 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• Tuples/Tuples.h (modified) (2 diffs)

src/AST/Expr.cpp ¶

@@ -20 +20 @@
 #include <vector>
 
+#include "Stmt.hpp"
 #include "Type.hpp"
 #include "Common/SemanticError.h"
@@ -25 +26 @@
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "ResolvExpr/typeops.h"    // for extractResultType
+#include "Tuples/Tuples.h"         // for makeTupleType
 
 namespace ast {
@@ -287 +289 @@
 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
 
+// --- ConstructorExpr
+
+ConstructorExpr::ConstructorExpr( const CodeLocation & loc, const Expr * call ) 
+: Expr( loc ), callExpr( call ) {
+        // allow resolver to type a constructor used as an expression if it has the same type as its 
+        // first argument
+        assert( callExpr );
+        const Expr * arg = InitTweak::getCallArg( callExpr, 0 );
+        assert( arg );
+        result = arg->result;
+}
+
+// --- CompoundLiteralExpr
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i )
+: Expr( loc ), init( i ) {
+        assert( t && i );
+        result.set_and_mutate( t )->set_lvalue( true );
+}
+
+// --- TupleExpr
+
+TupleExpr::TupleExpr( const CodeLocation & loc, std::vector<ptr<Expr>> && xs )
+: Expr( loc, Tuples::makeTupleType( xs ) ), exprs( xs ) {}
+
+// --- TupleIndexExpr
+
+TupleIndexExpr::TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i )
+: Expr( loc ), tuple( t ), index( i ) {
+        const TupleType * type = strict_dynamic_cast< const TupleType * >( tuple->result );
+        assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested "
+                "index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
+        // like MemberExpr, TupleIndexExpr is always an lvalue
+        result.set_and_mutate( type->types[ index ] )->set_lvalue( true );
+}
+
+// --- TupleAssignExpr
+
+TupleAssignExpr::TupleAssignExpr( 
+        const CodeLocation & loc, std::vector<ptr<Expr>> && assigns, 
+        std::vector<ptr<ObjectDecl>> && tempDecls )
+: Expr( loc, Tuples::makeTupleType( assigns ) ), stmtExpr() {
+        // convert internally into a StmtExpr which contains the declarations and produces the tuple of 
+        // the assignments
+        std::list<ptr<Stmt>> stmts;
+        for ( const ObjectDecl * obj : tempDecls ) {
+                stmts.emplace_back( new DeclStmt{ loc, obj } );
+        }
+        TupleExpr * tupleExpr = new TupleExpr{ loc, std::move(assigns) };
+        assert( tupleExpr->result );
+        stmts.emplace_back( new ExprStmt{ loc, tupleExpr } );
+        stmtExpr = new StmtExpr{ loc, new CompoundStmt{ loc, std::move(stmts) } };
+}
+
+// --- StmtExpr
+
+StmtExpr::StmtExpr( const CodeLocation & loc, const CompoundStmt * ss ) 
+: Expr( loc ), stmts( ss ), returnDecls(), dtors() { computeResult(); }
+
+void StmtExpr::computeResult() {
+        assert( stmts );
+        const std::list<ptr<Stmt>> & body = stmts->kids;
+        if ( ! returnDecls.empty() ) {
+                // prioritize return decl for result type, since if a return decl exists, then the StmtExpr 
+                // is currently in an intermediate state where the body will always give a void result type
+                result = returnDecls.front()->get_type();
+        } else if ( ! body.empty() ) {
+                if ( const ExprStmt * exprStmt = body.back().as< ExprStmt >() ) {
+                        result = exprStmt->expr->result;
+                }
+        }
+        // ensure a result type exists
+        if ( ! result ) { result = new VoidType{}; }
+}
+
+// --- UniqueExpr
+
+unsigned long long UniqueExpr::nextId = 0;
+
+UniqueExpr::UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1 )
+: Expr( loc, e->result ), id( i ) {
+        assert( expr );
+        if ( id == -1 ) {
+                assert( nextId != -1 );
+                id = nextId++;
+        }
 }
 

src/AST/Expr.hpp ¶

@@ -491 +491 @@
 public:
         ptr<Expr> inout;
-        ptr<Expr> constraint; 
+        ptr<Expr> constraint;
+        ptr<Expr> operand;
+
+        AsmExpr( const CodeLocation & loc, const Expr * io, const Expr * con, const Expr * op )
+        : Expr( loc ), inout( io ), constraint( con ), operand( op ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        AsmExpr * clone() const override { return new AsmExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// The application of a function to a set of parameters, along with a set of copy constructor 
+/// calls, one for each argument
+class ImplicitCopyCtorExpr final : public Expr {
+public:
+        ptr<ApplicationExpr> callExpr;
+        std::vector<ptr<ObjectDecl>> tempDecls;
+        std::vector<ptr<ObjectDecl>> returnDecls;
+        std::vector<ptr<ObjectDecl>> dtors;
+
+        ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
+        : Expr( loc, call->result ), tempDecls(), returnDecls(), dtors() { assert( call ); }
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Constructor in expression context, e.g. `int * x = alloc() { 42 };`
+class ConstructorExpr final : public Expr {
+public:
+        ptr<Expr> callExpr;
+
+        ConstructorExpr( const CodeLocation & loc, const Expr * call );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        ConstructorExpr * clone() const override { return new ConstructorExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A C99 compound literal, e.g. `(MyType){ a, b, c }`
+class CompoundLiteralExpr final : public Expr {
+public:
+        ptr<Init> init;
+
+        CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A range, e.g. `3 ... 5` or `1~10`
+class RangeExpr final : public Expr {
+public:
+        ptr<Expr> low;
+        ptr<Expr> high;
+
+        RangeExpr( const CodeLocation & loc, const Expr * l, const Expr * h )
+        : Expr( loc ), low( l ), high( h ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        RangeExpr * clone() const override { return new RangeExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A tuple expression before resolution, e.g. `[a, b, c]`
+class UntypedTupleExpr final : public Expr {
+public:
+        std::vector<ptr<Expr>> exprs;
+
+        UntypedTupleExpr( const CodeLocation & loc, std::vector<ptr<Expr>> && xs )
+        : Expr( loc ), exprs( std::move(xs) ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UntypedTupleExpr * clone() const override { return new UntypedTupleExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A tuple expression after resolution, e.g. `[a, b, c]`
+class TupleExpr final : public Expr {
+public:
+        std::vector<ptr<Expr>> exprs;
+
+        TupleExpr( const CodeLocation & loc, std::vector<ptr<Expr>> && xs );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        TupleExpr * clone() const override { return new TupleExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// An element selection operation on a tuple value, e.g. `t.3` after analysis
+class TupleIndexExpr final : public Expr {
+public:
+        ptr<Expr> tuple;
+        unsigned index;
+
+        TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        TupleIndexExpr * clone() const override { return new TupleIndexExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A multiple- or mass-assignment operation, or a tuple ctor/dtor expression. 
+/// multiple-assignment: both sides of the assignment have tuple type, 
+///     e.g. `[a, b, c] = [d, e, f];`
+/// mass-assignment: left-hand side has tuple type and right-hand side does not:
+///     e.g. `[a, b, c] = 42;`
+class TupleAssignExpr final : public Expr {
+public:
+        ptr<StmtExpr> stmtExpr;
+
+        TupleAssignExpr( 
+                const CodeLocation & loc, std::vector<ptr<Expr>> && assigns, 
+                std::vector<ptr<ObjectDecl>> && tempDecls );
+        
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A GCC "statement expression", e.g. `({ int x = 5; x })`
+class StmtExpr final : public Expr {
+public:
+        ptr<CompoundStmt> stmts;
+        std::vector<ptr<ObjectDecl>> returnDecls;  ///< return variable(s) for statement expression
+        std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
+
+        StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
+
+        /// Set the result type of this StmtExpr based on its body
+        void computeResult();
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        StmtExpr * clone() const override { return new StmtExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// An expression which must only be evaluated once
+class UniqueExpr final : public Expr {
+        static unsigned long long nextId;
+public:
+        ptr<Expr> expr;
+        ptr<ObjectDecl> object;
+        ptr<VariableExpr> var;
+        unsigned long long id;
+
+        UniqueExpr( const CodeLocation & loc, const Expr * e, unsigned long long i = -1 );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UniqueExpr * clone() const override { return new UniqueExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// One option for resolving an initializer expression
+struct InitAlternative {
+        ptr<Type> type;
+        ptr<Designation> designation;
+
+        InitAlternative() = default;
+        InitAlternative( const Type * ty, const Designation * des ) : type( ty ), designation( des ) {}
+};
+
+/// Pre-resolution initializer expression
+class UntypedInitExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+        std::vector<InitAlternative> initAlts;
+
+        UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::vector<InitAlternative> && as )
+        : Expr( loc ), expr( e ), initAlts( std::move(as) ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        UntypedInitExpr * clone() const override { return new UntypedInitExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Post-resolution initializer expression
+class InitExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+        ptr<Designation> designation;
+
+        InitExpr( const CodeLocation & loc, const Expr * e, const Designation * des )
+        : Expr( loc, e->result ), expr( e ), designation( des ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        InitExpr * clone() const override { return new InitExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Expression containing a deleted identifier.
+/// Internal to resolver.
+class DeletedExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+        readonly<Node> deleteStmt;
+
+        DeletedExpr( const CodeLocation & loc, const Expr * e, const Node * del )
+        : Expr( loc, e->result ), expr( e ), deleteStmt( del ) { assert( expr->result ); }
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DeletedExpr * clone() const override { return new DeletedExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// Use of a default argument.
+/// Internal to resolver.
+class DefaultArgExpr final : public Expr {
+public:
+        ptr<Expr> expr;
+
+        DefaultArgExpr( const CodeLocation & loc, const Expr * e )
+        : Expr( loc, e->result ), expr( e ) { assert( e->result ); }
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DefaultArgExpr * clone() const override { return new DefaultArgExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// C11 _Generic expression
+class GenericExpr final : public Expr {
+public:
+        /// One arm of the _Generic expr
+        struct Association {
+                ptr<Type> type;
+                ptr<Expr> expr;
+
+                Association() = default;
+                // default case
+                Association( const Expr * e ) : type(), expr( e ) {}
+                // non-default case
+                Association( const Type * t, const Expr * e ) : type( t ), expr( e ) {}
+        };
+
+        ptr<Expr> control;
+        std::vector<Association> associations;
+
+        GenericExpr( const CodeLocation & loc, const Expr * ctrl, std::vector<Association> && assns )
+        : Expr( loc ), control( ctrl ), associations( std::move(assns) ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        GenericExpr * clone() const override { return new GenericExpr{ *this }; }
+        MUTATE_FRIEND
 };
 
@@ -545 +805 @@
 inline void increment( const class AsmExpr * node, Node::ref_type ref ) { node->increment(ref); }
 inline void decrement( const class AsmExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class ConstructorExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class ConstructorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class UntypedValofExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class UntypedValofExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class RangeExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class RangeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class TupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class TupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class TupleIndexExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class TupleIndexExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class TupleAssignExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class TupleAssignExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class StmtExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class StmtExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class UniqueExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class UniqueExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class UntypedInitExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class UntypedInitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class InitExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class InitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class DeletedExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class DeletedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class DefaultArgExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class DefaultArgExpr * node, Node::ref_type ref ) { node->decrement(ref); }
-// inline void increment( const class GenericExpr * node, Node::ref_type ref ) { node->increment(ref); }
-// inline void decrement( const class GenericExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class ImplicitCopyCtorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class ConstructorExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class ConstructorExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class CompoundLiteralExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class RangeExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class RangeExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class UntypedTupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TupleExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TupleExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TupleIndexExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TupleIndexExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class TupleAssignExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class TupleAssignExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class StmtExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class StmtExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class UniqueExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class UniqueExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class UntypedInitExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class UntypedInitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class InitExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class InitExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class DeletedExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class DeletedExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class DefaultArgExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class DefaultArgExpr * node, Node::ref_type ref ) { node->decrement(ref); }
+inline void increment( const class GenericExpr * node, Node::ref_type ref ) { node->increment(ref); }
+inline void decrement( const class GenericExpr * node, Node::ref_type ref ) { node->decrement(ref); }
 }
 

src/AST/Fwd.hpp ¶

@@ -85 +85 @@
 class ConstructorExpr;
 class CompoundLiteralExpr;
-class UntypedValofExpr;
 class RangeExpr;
 class UntypedTupleExpr;
@@ -267 +266 @@
 inline void increment( const class CompoundLiteralExpr *, Node::ref_type );
 inline void decrement( const class CompoundLiteralExpr *, Node::ref_type );
-inline void increment( const class UntypedValofExpr *, Node::ref_type );
-inline void decrement( const class UntypedValofExpr *, Node::ref_type );
 inline void increment( const class RangeExpr *, Node::ref_type );
 inline void decrement( const class RangeExpr *, Node::ref_type );

src/AST/Type.hpp ¶

@@ -23 +23 @@
 
 #include "CVQualifiers.hpp"
-#include "Decl.hpp"
+#include "Decl.hpp"          // for AggregateDecl subclasses
 #include "Fwd.hpp"
 #include "Node.hpp"          // for Node, ptr

src/AST/porting.md ¶

@@ -68 +68 @@
 * prefer `#pragma once` over `#ifdef` guards
 * namespaces that cover entire files don't get indented
+* The general node headers only `#include "Fwd.hpp"` if they can get away with it
+  * Anything that needs definitions goes in the .cpp file
+  * `Type.hpp` includes `Decl.hpp` so that it knows the `AggregateDecl` subclasses for `ReferenceToType::aggr()` overloads
 
 ### Documentation ###
@@ -166 +169 @@
 * un-defaulted constructor parameter determining `&&` or `||`
 
+`CompoundLiteralExpr`
+* `initializer` => `init`
+
+`RangeExpr`
+* removed `set_low`, `set_high` due to disuse
+
+`TupleIndexExpr`
+* removed `set_tuple`, `set_index` due to disuse
+
+`GenericExpr`
+* `Association::isDefault` removed: `! type` is equivalent
+
+`StmtExpr`
+* `statements` => `stmts`
+
 `Init`
 * `bool maybeConstruct` => `enum ConstructFlag { DoConstruct, MaybeConstruct }`

src/InitTweak/InitTweak.cc ¶

@@ -5 +5 @@
 #include <memory>                  // for __shared_ptr
 
+#include "AST/Expr.hpp"
+#include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
@@ -27 +29 @@
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
 
-class UntypedValofExpr;
-
 namespace InitTweak {
         namespace {
@@ -433 +433 @@
                         assert( false );
                 }
+
+                // template<typename CallExpr>
+                // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
+                //      if( pos >= call->args.size() ) {
+                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", 
+                //                      pos, toString( call ).c_str() );
+                //      }
+                //      for ( const ast::Expr * arg : call->args ) {
+                //              if ( pos == 0 ) return arg;
+                //              --pos;
+                //      }
+                //      assert( false );
+                // }
         }
 
@@ -452 +465 @@
                         assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
                 }
+        }
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
+                assert(!"implemented; needs to build AST/Expr.cpp");
+                // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
+                //      return callArg( app, pos );
+                // } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
+                //      return callArg( untyped, pos );
+                // } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
+                //      const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
+                //      assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
+                //      const ExprStmt * stmt = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back() );
+                //      const TupleExpr * tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr );
+                //      assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
+                //      return getCallArg( tuple->exprs.front(), pos );
+                // } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
+                //      return getCallArg( ctor->callExpr, pos );
+                // } else {
+                //      assertf( false, "Unexpected expression type passed to getCallArg: %s", 
+                //              toString( call ).c_str() );
+                // }
         }
 
@@ -516 +549 @@
         const ast::Type* getPointerBase( const ast::Type* t ) {
                 assert(!"needs to build Type.cpp before inclusion");
-                // if ( const ast::PointerType* p = dynamic_cast< const ast::PointerType* >( t ) ) {
+                // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
                 //      return p->base;
-                // } else if ( const ast::ArrayType* a = dynamic_cast< const ast::ArrayType* >( t ) ) {
+                // } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
                 //      return a->base;
-                // } else if ( const ast::ReferenceType* r = dynamic_cast< const ast::ReferenceType* >( t ) ) {
+                // } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
                 //      return r->base;
                 // } else return nullptr;

src/InitTweak/InitTweak.h ¶

@@ -81 +81 @@
         /// returns the argument to a call expression in position N indexed from 0
         Expression *& getCallArg( Expression * callExpr, unsigned int pos );
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos );
 
         /// returns the base type of a PointerType or ArrayType, else returns NULL

src/SynTree/SynTree.h ¶

@@ -90 +90 @@
 class ConstructorExpr;
 class CompoundLiteralExpr;
-class UntypedValofExpr;
 class RangeExpr;
 class UntypedTupleExpr;

src/Tuples/TupleExpansion.cc ¶

@@ -17 +17 @@
 #include <cassert>                // for assert
 #include <list>                   // for list
-
+#include <vector>
+
+#include "AST/CVQualifiers.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
 #include "Common/ScopedMap.h"     // for ScopedMap
@@ -314 +319 @@
                 return new TupleType( qualifiers, types );
         }
+        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
+                assert(!"implemented; needs Type.cpp in build");
+                // // produce the TupleType which aggregates the types of the exprs
+                // std::vector<ast::ptr<ast::Type>> types;
+                // ast::CV::Qualifiers quals{ 
+                //      ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue | 
+                //      ast::CV::Atomic | ast::CV::Mutex };
+                
+                // for ( const ast::Expr * expr : exprs ) {
+                //      assert( expr->result );
+                //      // if the type of any expr is void, the type of the entire tuple is void
+                //      if ( expr->result->isVoid() ) return new ast::VoidType{};
+
+                //      // qualifiers on the tuple type are the qualifiers that exist on all components
+                //      quals &= expr->result->qualifiers;
+
+                //      types.emplace_back( expr->result );
+                // }
+
+                // if ( exprs.empty() ) { quals = ast::CV::Qualifiers{}; }
+                // return new ast::TupleType{ std::move(types), quals };
+        }
 
         TypeInstType * isTtype( Type * type ) {

src/Tuples/Tuples.h ¶

@@ -19 +19 @@
 #include <vector>
 
+#include "AST/Fwd.hpp"
+#include "AST/Node.hpp"
 #include "SynTree/Expression.h"
 #include "SynTree/Declaration.h"
@@ -42 +44 @@
         /// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types
         Type * makeTupleType( const std::list< Expression * > & exprs );
+        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs );
 
         /// returns a TypeInstType if `type` is a ttype, nullptr otherwise