Changeset 7edd5c1

Timestamp:

May 9, 2022, 11:38:08 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

00675a1

Parents:

bd1d279

Message:

Assorted fixes to the AST, found while I was trying to add more invarant checks.

Location:

src

Files:

• AST/Convert.cpp (modified) (3 diffs)
• AST/Copy.cpp (modified) (2 diffs)
• AST/Decl.cpp (modified) (3 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (1 diff)
• AST/Node.hpp (modified) (2 diffs)
• AST/Stmt.cpp (modified) (2 diffs)
• Validate/Autogen.cpp (modified) (2 diffs)

src/AST/Convert.cpp

@@ -93 +93 @@
         };
 
-    template<typename T>
-    Getter<T> get() {
-        return Getter<T>{ *this };
-    }
+        template<typename T>
+        Getter<T> get() {
+                return Getter<T>{ *this };
+        }
 
         Label makeLabel(Statement * labelled, const ast::Label& label) {
@@ -1651 +1651 @@
                         // GET_ACCEPT_1(type, FunctionType),
                         std::move(forall),
+                        std::move(assertions),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1664 +1665 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);

src/AST/Copy.cpp

@@ -10 +10 @@
 // Created On       : Thr Nov 11  9:16:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:28:00 2021
-// Update Count     : 0
+// Last Modified On : Tue May  3 16:28:00 2022
+// Update Count     : 1
 //
 
@@ -77 +77 @@
         }
 
+        void postvisit( const UniqueExpr * node ) {
+                readonlyInsert( &node->object );
+        }
+
         void postvisit( const MemberExpr * node ) {
                 readonlyInsert( &node->member );

src/AST/Decl.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 12 16:54:55 2021
-// Update Count     : 23
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:10:00 2022
+// Update Count     : 24
 //
 
@@ -53 +53 @@
 // --- FunctionDecl
 
-FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
         std::vector<ptr<TypeDecl>>&& forall,
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
@@ -74 +74 @@
         }
         this->type = ftype;
+}
+
+FunctionDecl::FunctionDecl( const CodeLocation & location, const std::string & name,
+        std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+        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)
+: DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
+                params( std::move(params) ), returns( std::move(returns) ),
+                type_params( std::move( forall) ), assertions( std::move( assertions ) ),
+                type( nullptr ), stmts( stmts ) {
+        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        for ( auto & param : this->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto & ret : this->returns ) {
+                type->returns.emplace_back( ret->get_type() );
+        }
+        for ( auto & param : this->type_params ) {
+                type->forall.emplace_back( new TypeInstType( param ) );
+        }
+        for ( auto & assertion : this->assertions ) {
+                type->assertions.emplace_back(
+                        new VariableExpr( assertion->location, assertion ) );
+        }
+        this->type = type;
 }
 

src/AST/Decl.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:25:05 2021
-// Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:09:00 2022
+// Update Count     : 33
 //
 
@@ -135 +135 @@
         std::vector< ptr<Expr> > withExprs;
 
+        // The difference between the two constructors is in how they handle
+        // assertions. The first constructor uses the assertions from the type
+        // parameters, in the style of the old ast, and puts them on the type.
+        // The second takes an explicite list of assertions and builds a list of
+        // references to them on the type.
+
         FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
-        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-        //  stmts( stmts ) {}
+
+        FunctionDecl( const CodeLocation & location, const std::string & name,
+                std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
         const Type * get_type() const override;

src/AST/Expr.hpp

@@ -784 +784 @@
 public:
         ptr<Expr> expr;
-        ptr<ObjectDecl> object;
+        readonly<ObjectDecl> object;
         ptr<VariableExpr> var;
         unsigned long long id;

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 25 10:33:00 2022
-// Update Count     : 7
+// Last Modified On : Mon May  9 10:20:00 2022
+// Update Count     : 8
 //
 
@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
-        bool isManaged() const {return strong_count > 0; }
+        bool isManaged() const { return strong_count > 0; }
+        bool isReferenced() const { return weak_count > 0; }
 
 private:

src/AST/Stmt.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 19:01:20 2022
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May  3 15:18:20 2022
+// Update Count     : 4
 //
 
 #include "Stmt.hpp"
 
-
+#include "Copy.hpp"
 #include "DeclReplacer.hpp"
 #include "Type.hpp"
@@ -23 +23 @@
 
 // --- CompoundStmt
-CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids(other.kids) {
+CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids() {
+        // Statements can have weak references to them, if that happens inserting
+        // the original node into the new list will put the original node in a
+        // bad state, where it cannot be mutated. To avoid this, just perform an
+        // additional shallow copy on the statement.
+        for ( const Stmt * kid : other.kids ) {
+                if ( kid->isReferenced() ) {
+                        kids.emplace_back( ast::shallowCopy( kid ) );
+                } else {
+                        kids.emplace_back( kid );
+                }
+        }
+
         // when cloning a compound statement, we may end up cloning declarations which
         // are referred to by VariableExprs throughout the block. Cloning a VariableExpr

src/Validate/Autogen.cpp

@@ -350 +350 @@
                 name,
                 std::move( type_params ),
+                std::move( assertions ),
                 std::move( params ),
                 std::move( returns ),
@@ -360 +361 @@
                 // Auto-generated routines are inline to avoid conflicts.
                 ast::Function::Specs( ast::Function::Inline ) );
-        decl->assertions = std::move( assertions );
         decl->fixUniqueId();
         return decl;