Changes in / [dd7c2ce0:1da2affb]

Location:

src/AST

Files:

• Decl.hpp (modified) (6 diffs)
• Stmt.hpp (modified) (6 diffs)

src/AST/Decl.hpp

@@ -125 +125 @@
 
 /// Object declaration `int foo()`
-class FunctionDecl final : public DeclWithType {
+class FunctionDecl : public DeclWithType {
 public:
         std::vector<ptr<TypeDecl>> type_params;
@@ -314 +314 @@
 class EnumDecl final : public AggregateDecl {
 public:
-        // isTyped indicated if the enum has a declaration like:
+        bool isTyped; // isTyped indicated if the enum has a declaration like:
         // enum (type_optional) Name {...}
-        bool isTyped;
-        // if isTyped == true && base.get() == nullptr, it is a "void" type enum
-        ptr<Type> base;
+        ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
         enum class EnumHiding { Visible, Hide } hide;
 
@@ -376 +374 @@
 
 /// Assembly declaration: `asm ... ( "..." : ... )`
-class AsmDecl final : public Decl {
+class AsmDecl : public Decl {
 public:
         ptr<AsmStmt> stmt;
 
         AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
-        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
+        : Decl( loc, "", {}, {} ), stmt(stmt) {}
 
         const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -390 +388 @@
 
 /// C-preprocessor directive `#...`
-class DirectiveDecl final : public Decl {
+class DirectiveDecl : public Decl {
 public:
         ptr<DirectiveStmt> stmt;
 
         DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
-        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
+        : Decl( loc, "", {}, {} ), stmt(stmt) {}
 
         const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -404 +402 @@
 
 /// Static Assertion `_Static_assert( ... , ... );`
-class StaticAssertDecl final : public Decl {
+class StaticAssertDecl : public Decl {
 public:
         ptr<Expr> cond;
@@ -410 +408 @@
 
         StaticAssertDecl( const CodeLocation & loc, const Expr * condition, const ConstantExpr * msg )
-        : Decl( loc, "", {}, Linkage::C ), cond( condition ), msg( msg ) {}
+        : Decl( loc, "", {}, {} ), cond( condition ), msg( msg ) {}
 
         const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Stmt.hpp

@@ -28 +28 @@
 // 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 * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
@@ -340 +340 @@
 
         CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                        const Stmt * body )
+                           const Stmt * body )
                 : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
 
@@ -380 +380 @@
 // Base class of WaitFor/WaitUntil statements
 // form: KEYWORD(...) ... timeout(...) ... else ...
-class WaitStmt : public Stmt {
-  public:
-        ptr<Expr> timeout_time;
+class WaitStmt : public Stmt { 
+  public:
+    ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
@@ -388 +388 @@
         ptr<Expr> else_cond;
 
-        WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+    WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
 
   private:
-        WaitStmt * clone() const override = 0;
+    WaitStmt * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -444 +444 @@
 class WaitUntilStmt final : public WaitStmt {
   public:
-        // Non-ast node used during compilation to store data needed to generate predicates
-        //    and set initial status values for clauses
-        // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
-        struct ClauseNode {
-                enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
-                // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
-
-                ClauseNode * left;
-                ClauseNode * right;
-                WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
-
-                bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
-                bool whenState;     // used to track if when_cond is toggled on or off for generating init values
-                bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
-
-                ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
-                        : op(op), left(left), right(right), leaf(nullptr),
-                        ambiguousWhen(false), whenState(true), childOfAnd(false) {}
-                ClauseNode( Op op, WhenClause * leaf )
-                        : op(op), left(nullptr), right(nullptr), leaf(leaf),
-                        ambiguousWhen(false), whenState(true), childOfAnd(false) {}
-                ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
-
-                ~ClauseNode() {
-                        if ( left ) delete left;
-                        if ( right ) delete right;
-                }
-        };
+    // Non-ast node used during compilation to store data needed to generate predicates
+    //    and set initial status values for clauses
+    // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+    struct ClauseNode { 
+        enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+        // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+
+        ClauseNode * left;
+        ClauseNode * right;
+        WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+
+        bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+        bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+        bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+
+        ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+            : op(op), left(left), right(right), leaf(nullptr), 
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( Op op, WhenClause * leaf )
+            : op(op), left(nullptr), right(nullptr), leaf(leaf),
+            ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+        ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+        
+        ~ClauseNode() {
+            if ( left ) delete left;
+            if ( right ) delete right;
+        }
+    };
 
         std::vector<ptr<WhenClause>> clauses;
-        ClauseNode * predicateTree;
+    ClauseNode * predicateTree;
 
         WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : WaitStmt(loc, std::move(labels)) {}
 
-        ~WaitUntilStmt() { delete predicateTree; }
+    ~WaitUntilStmt() { delete predicateTree; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -522 +522 @@
         std::vector<ptr<Expr>> mutexObjs;
 
-        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
+        MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
                            const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}