Changeset 3f681b1

Timestamp:

May 11, 2022, 11:33:21 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

7675f58

Parents:

e6bb667

Message:

Added the new invariant checks. There seems to be a few unset locations in the multi-level exit code.

Location:

src

Files:

• AST/Label.hpp (modified) (1 diff)
• AST/Node.hpp (modified) (1 diff)
• AST/Pass.proto.hpp (modified) (3 diffs)
• AST/Util.cpp (modified) (3 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (2 diffs)

src/AST/Label.hpp ¶

@@ -34 +34 @@
         std::vector< ptr<Attribute> > attributes;
 
-        Label( CodeLocation loc, const std::string& name = "",
+        Label( const CodeLocation& loc, const std::string& name = "",
                 std::vector<ptr<Attribute>> && attrs = std::vector<ptr<Attribute>>{} )
         : location( loc ), name( name ), attributes( attrs ) {}

src/AST/Node.hpp ¶

@@ -51 +51 @@
         bool isManaged() const { return strong_count > 0; }
         bool isReferenced() const { return weak_count > 0; }
+        bool isStable() const {
+                return (1 == strong_count || (1 < strong_count && 0 == weak_count));
+        }
 
 private:

src/AST/Pass.proto.hpp ¶

@@ -131 +131 @@
         template< typename node_t >
         struct result1 {
-                bool differs;
-                const node_t * value;
+                bool differs = false;
+                const node_t * value = nullptr;
 
                 template< typename object_t, typename super_t, typename field_t >
@@ -151 +151 @@
                 };
 
-                bool differs;
+                bool differs = false;
                 container_t< delta > values;
 
@@ -167 +167 @@
         template< template<class...> class container_t, typename node_t >
         struct resultN {
-                bool differs;
+                bool differs = false;
                 container_t<ptr<node_t>> values;
 

src/AST/Util.cpp ¶

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Util.hpp -- General utilities for working with the AST.
+// Util.cpp -- General utilities for working with the AST.
 //
 // Author           : Andrew Beach
 // Created On       : Wed Jan 19  9:46:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 11 18:07:00 2022
-// Update Count     : 1
+// Last Modified On : Wed May  4 15:50:00 2022
+// Update Count     : 2
 //
 
@@ -46 +46 @@
 
 /// Check that every note that can has a set CodeLocation.
-struct SetCodeLocationsCore {
-        void previsit( const ParseNode * node ) {
-                assert( node->location.isSet() );
+void isCodeLocationSet( const ParseNode * node ) {
+        assert( node->location.isSet() );
+}
+
+/// Make sure the reference counts are in a valid combination.
+void isStable( const Node * node ) {
+        assert( node->isStable() );
+}
+
+/// Check that a FunctionDecl is synchronized with it's FunctionType.
+void functionDeclMatchesType( const FunctionDecl * decl ) {
+        // The type is a cache of sorts, if it is missing that is only a
+        // problem if isTypeFixed is set.
+        if ( decl->isTypeFixed ) {
+                assert( decl->type );
+        } else if ( !decl->type ) {
+                return;
         }
-};
+
+        const FunctionType * type = decl->type;
+
+        // Check that `type->forall` corresponds with `decl->type_params`.
+        assert( type->forall.size() == decl->type_params.size() );
+        // Check that `type->assertions` corresponds with `decl->assertions`.
+        assert( type->assertions.size() == decl->assertions.size() );
+        // Check that `type->params` corresponds with `decl->params`.
+        assert( type->params.size() == decl->params.size() );
+        // Check that `type->returns` corresponds with `decl->returns`.
+        assert( type->returns.size() == decl->returns.size() );
+}
 
 struct InvariantCore {
@@ -56 +81 @@
         // None of the passes should make changes so ordering doesn't matter.
         NoStrongCyclesCore no_strong_cycles;
-        SetCodeLocationsCore set_code_locations;
 
         void previsit( const Node * node ) {
                 no_strong_cycles.previsit( node );
+                isStable( node );
         }
 
         void previsit( const ParseNode * node ) {
-                no_strong_cycles.previsit( node );
-                set_code_locations.previsit( node );
+                previsit( (const Node *)node );
+                isCodeLocationSet( node );
+        }
+
+        void previsit( const FunctionDecl * node ) {
+                previsit( (const ParseNode *)node );
+                functionDeclMatchesType( node );
         }
 

src/ControlStruct/MultiLevelExit.cpp ¶

@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
+#include "Common/CodeLocationTools.hpp"
 #include "LabelGeneratorNew.hpp"
 
@@ -618 +619 @@
         Pass<MultiLevelExitCore> visitor( labelTable );
         const CompoundStmt * ret = stmt->accept( visitor );
-        return ret;
+        // There are some unset code locations slipping in, possibly by Labels.
+        const Node * node = localFillCodeLocations( ret->location, ret );
+        return strict_dynamic_cast<const CompoundStmt *>( node );
 }
 } // namespace ControlStruct