Changeset a1da039

Timestamp:

Oct 24, 2023, 3:00:53 PM (14 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

dd7c2ce0

Parents:

d8a0e51

Message:

Make all new declarations have a properly defined LinkageSpec?. Also some general clean-up.

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