Changeset 4864a73 for src

Timestamp:

Jun 5, 2019, 4:28:28 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

0ce063b

Parents:

2a8f0c1

Message:

Added chain mutation and example use in resolver

Location:

src

Files:

• AST/Chain.hpp (added)
• AST/Node.cpp (modified) (1 diff)
• AST/Node.hpp (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)

src/AST/Node.cpp

@@ -34 +34 @@
 template< typename node_t, enum ast::Node::ref_type ref_t >
 void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
 
 template< typename node_t, enum ast::Node::ref_type ref_t >

src/AST/Node.hpp

@@ -46 +46 @@
         };
 
+        bool unique() const { return strong_count == 1; }
+
 private:
         /// Make a copy of this node; should be overridden in subclass with more precise return type
@@ -56 +58 @@
         mutable size_t strong_count = 0;
         mutable size_t weak_count = 0;
+        mutable bool was_ever_strong = false;
 
         void increment(ref_type ref) const {
                 switch (ref) {
-                        case ref_type::strong: strong_count++; break;
+                        case ref_type::strong: strong_count++; was_ever_strong = true; break;
                         case ref_type::weak  : weak_count  ++; break;
                 }
@@ -176 +179 @@
         }
 
-        const node_t * get() const { return  node; }
-        const node_t * operator->() const { return  node; }
-        const node_t & operator* () const { return *node; }
-        explicit operator bool() const { return node; }
-        operator const node_t * () const { return node; }
+        const node_t * get() const { _check(); return  node; }
+        const node_t * operator->() const { _check(); return  node; }
+        const node_t & operator* () const { _check(); return *node; }
+        explicit operator bool() const { _check(); return node; }
+        operator const node_t * () const { _check(); return node; }
 
         /// wrapper for convenient access to dynamic_cast
         template<typename o_node_t>
-        const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
 
         /// wrapper for convenient access to strict_dynamic_cast
@@ -208 +211 @@
         void _inc( const node_t * other );
         void _dec( const node_t * other );
+        void _check() const;
 
 protected:

src/ResolvExpr/Resolver.cc

@@ -27 +27 @@
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "AST/Chain.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
@@ -407 +408 @@
 
         void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
+                // class-variable initContext is changed multiple time because the LHS is analysed twice.
+                // The second analysis changes initContext because of a function type can contain object
+                // declarations in the return and parameter types. So each value of initContext is
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -447 +448 @@
 
         void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I
@@ -939 +940 @@
         ///////////////////////////////////////////////////////////////////////////
 
-        class Resolver_new final 
-        : public ast::WithSymbolTable, public ast::WithGuards, 
-          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting, 
+        class Resolver_new final
+        : public ast::WithSymbolTable, public ast::WithGuards,
+          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
           public ast::WithStmtsToAdd<> {
-        
+
                 ast::ptr< ast::Type > functionReturn = nullptr;
                 // ast::CurrentObject currentObject = nullptr;
                 // bool inEnumDecl = false;
 
-        public: 
+        public:
                 Resolver_new() = default;
                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
@@ -991 +992 @@
 
         const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 ast::ptr< ast::FunctionDecl > ret = functionDecl;
                 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
                         const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
-                        
+
                         if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
                                 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
                                         if ( init->value->env == nullptr ) continue;
                                         // clone initializer minus the initializer environment
-                                        strict_dynamic_cast< ast::SingleInit * >(
-                                                strict_dynamic_cast< ast::ObjectDecl * >( 
-                                                        ret.get_and_mutate()->type.get_and_mutate()->params[i].get_and_mutate()
-                                                )->init.get_and_mutate()
-                                        )->value.get_and_mutate()->env = nullptr;
+                                        ast::chain_mutate( ret )
+                                                ( &ast::FunctionDecl::type )
+                                                        ( &ast::FunctionType::params )
+                                                                [i]
+                                                                ( &ast::ObjectDecl::init )
+                                                                        ( &ast::SingleInit::value )->env = nullptr;
+
+                                        assert( functionDecl != ret.get() || functionDecl->unique() );
+                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
                                 }
                         }