Changeset a085470 for src/AST

Timestamp:

Apr 10, 2023, 12:03:31 PM (3 years ago)

Author:

Mike Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, master

Children:

6adeb5f

Parents:

2b01f8e (diff), ea2759b (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

• Convert.cpp (modified) (4 diffs)
• Decl.cpp (modified) (2 diffs)
• Decl.hpp (modified) (4 diffs)
• Pass.impl.hpp (modified) (1 diff)
• Print.cpp (modified) (1 diff)
• Stmt.hpp (modified) (4 diffs)
• Type.cpp (modified) (2 diffs)
• Type.hpp (modified) (3 diffs)

src/AST/Convert.cpp

@@ -559 +559 @@
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
-                switch(node->type) {
+                switch (node->kind) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
@@ -1683 +1683 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 
@@ -1989 +1989 @@
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
-                        old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );
@@ -2131 +2131 @@
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::SuspendStmt::Type type;
+                ast::SuspendStmt::Kind type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;

src/AST/Decl.cpp

@@ -57 +57 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
         type_params(std::move(forall)), assertions(),
         params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
-        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        FunctionType * ftype = new FunctionType( isVarArgs );
         for (auto & param : this->params) {
                 ftype->params.emplace_back(param->get_type());
@@ -81 +81 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
                 type_params( std::move( forall) ), assertions( std::move( assertions ) ),
                 params( std::move(params) ), returns( std::move(returns) ),
                 type( nullptr ), stmts( stmts ) {
-        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        FunctionType * type = new FunctionType( isVarArgs );
         for ( auto & param : this->params ) {
                 type->params.emplace_back( param->get_type() );

src/AST/Decl.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:44:00 2022
-// Update Count     : 34
+// Last Modified On : Wed Apr  5 10:42:00 2023
+// Update Count     : 35
 //
 
@@ -122 +122 @@
 };
 
+/// Function variable arguments flag
+enum ArgumentFlag { FixedArgs, VariableArgs };
+
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
@@ -144 +147 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         FunctionDecl( const CodeLocation & location, const std::string & name,
@@ -150 +153 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         const Type * get_type() const override;

src/AST/Pass.impl.hpp

@@ -2042 +2042 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
-                maybe_accept( node, &TupleType::members );
         }
 

src/AST/Print.cpp

@@ -739 +739 @@
         virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
                 os << "Suspend Statement";
-                switch (node->type) {
-                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
-                        case ast::SuspendStmt::Generator: os << " for generator"; break;
-                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                switch (node->kind) {
+                case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                case ast::SuspendStmt::Generator: os << " for generator"; break;
+                case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
                 }
                 os << endl;

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 20 14:34:00 2022
-// Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 
@@ -205 +205 @@
 };
 
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
+
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
@@ -212 +215 @@
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
-        bool isDoWhile;
+        WhileDoKind isDoWhile;
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
@@ -364 +367 @@
   public:
         ptr<CompoundStmt> then;
-        enum Type { None, Coroutine, Generator } type = None;
-
-        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+        enum Kind { None, Coroutine, Generator } kind = None;
+
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Kind kind, const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), then(then), kind(kind) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Type.cpp

@@ -10 +10 @@
 // Created On       : Mon May 13 15:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:49:00 2022
-// Update Count     : 6
+// Last Modified On : Thu Apr  6 15:59:00 2023
+// Update Count     : 7
 //
 
@@ -199 +199 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ), members() {
-        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
-        // named, but members without initializer nodes end up getting constructors, which breaks
-        // things. This happens because the object decls have to be visited so that their types are
-        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
-        // be eliminated and replaced with a list-view over members. The temporary solution is to
-        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
-        // constructed. Potential better solutions include:
-        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
-        //      similar to the aggregate types.
-        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
-        //      by `genInit`, rather than the current boolean flag.
-        members.reserve( types.size() );
-        for ( const Type * ty : types ) {
-                members.emplace_back( new ObjectDecl{
-                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
-                        Storage::Classes{}, Linkage::Cforall } );
-        }
-}
+: Type( q ), types( std::move(ts) ) {}
 
 bool isUnboundType(const Type * type) {

src/AST/Type.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:47:00 2022
-// Update Count     : 8
+// Last Modified On : Thu Apr  6 15:58:00 2023
+// Update Count     : 9
 //
 
@@ -265 +265 @@
 };
 
-/// Function variable arguments flag
-enum ArgumentFlag { FixedArgs, VariableArgs };
-
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {
@@ -460 +457 @@
 public:
         std::vector<ptr<Type>> types;
-        std::vector<ptr<Decl>> members;
 
         TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q = {} );