Changeset 76ed81f for src/AST

Timestamp:

May 22, 2019, 5:22:30 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

893e106

Parents:

6380f78

Message:

Broken stuff pre-Pass fix

Location:

src/AST

Files:

• Expr.cpp (modified) (1 diff)
• GenericSubstitution.cpp (modified) (1 diff)
• Node.cpp (modified) (2 diffs)
• Node.hpp (modified) (1 diff)
• Print.cpp (modified) (1 diff)
• Type.hpp (modified) (1 diff)
• TypeSubstitution.hpp (modified) (4 diffs)

src/AST/Expr.cpp

@@ -159 +159 @@
         assert( aggregate->result );
 
+        // #warning Needs GenericSubsitution.cpp building to work correctly
+        // result.set_and_mutate( mem->get_type() )->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;  // FIXME temporary patch
+
         // take ownership of member type
-        Type * res = result.set_and_mutate( mem->get_type() );
+        result = mem->get_type();
         // substitute aggregate generic parameters into member type
-        genericSubsitution( aggregate->result ).apply( res );
+        genericSubsitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
-        res->set_lvalue( true );
-        res->qualifiers |= aggregate->result->qualifiers;
-        // ensure changes propegated back into result
-        result = res;
+        result.get_and_mutate()->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;
 }
 

src/AST/GenericSubstitution.cpp

@@ -31 +31 @@
                 TypeSubstitution sub;
 
-                void previsit( const Type * ty ) {
+                const Type * previsit( const Type * ty ) {
                         assertf( false, "Attempted generic substitution for non-aggregate type: %s", 
                                 toString( ty ).c_str() );
+                        return ty;
                 }
 
-                void previsit( const ReferenceType * ) {
+                const ReferenceType * previsit( const ReferenceType * ty ) {
                         // do nothing; allows substitution from base type
+                        return ty;
                 }
 
-                void previsit( const ReferenceToType * ty ) {
+                const ReferenceToType * previsit( const ReferenceToType * ty ) {
+                        visit_children = false;
                         // build substitution from base parameters
                         const AggregateDecl * aggr = ty->aggr();
                         sub = TypeSubstitution{ aggr->params.begin(), aggr->params.end(), ty->params.begin() };
-                        visit_children = false;
+                        return ty;
                 }
         };

src/AST/Node.cpp

@@ -35 +35 @@
 void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
 
-/// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
-/// Returns a mutable version of the pointer in this node.
-template< typename node_t, enum ast::Node::ref_type ref_t >
-node_t * ast::ptr_base<node_t, ref_t>::set_and_mutate( const node_t * n ) {
-        // ensure ownership of `n` by this node to avoid spurious single-owner mutates
-        assign( n );
+template< typename node_t, enum ast::Node::ref_type ref_t >
+node_t * ast::ptr_base<node_t, ref_t>::get_and_mutate() {
         // get mutable version of `n`
         auto r = mutate( node );
@@ -46 +42 @@
         assign( r );
         return r;
+}
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+node_t * ast::ptr_base<node_t, ref_t>::set_and_mutate( const node_t * n ) {
+        // ensure ownership of `n` by this node to avoid spurious single-owner mutates
+        assign( n );
+        // return mutable version
+        return get_and_mutate();
 }
 

src/AST/Node.hpp

@@ -147 +147 @@
         const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
 
+        /// Returns a mutable version of the pointer in this node.
+        node_t * get_and_mutate();
+
         /// Sets this pointer to a mutated version of a pointer (possibly) owned elsehere.
         /// Returns a mutable version of the pointer in this node.

src/AST/Print.cpp

@@ -495 +495 @@
 
         virtual const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * node ) {
+                os << indent << "Types:" << std::endl;
+                for ( const auto& i : *node ) {
+                        os << indent+1 << i.first << " -> ";
+                        indent += 2;
+                        i.second->accept( *this );
+                        indent -= 2;
+                        os << std::endl;
+                }
+                os << indent << "Non-types:" << std::endl;
+                for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
+                        os << indent+1 << i->first << " -> ";
+                        indent += 2;
+                        i->second->accept( *this );
+                        indent -= 2;
+                        os << std::endl;
+                }
                 return node;
         }

src/AST/Type.hpp

@@ -47 +47 @@
         bool is_atomic() const { return qualifiers.is_atomic; }
 
-        void set_const( bool v ) { qualifiers.is_const = v; }
-        void set_restrict( bool v ) { qualifiers.is_restrict = v; }
-        void set_lvalue( bool v ) { qualifiers.is_lvalue = v; }
-        void set_mutex( bool v ) { qualifiers.is_mutex = v; }
-        void set_atomic( bool v ) { qualifiers.is_atomic = v; }
+        Type * set_const( bool v ) { qualifiers.is_const = v; return this; }
+        Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; }
+        Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; }
+        Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; }
+        Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; }
 
         /// How many elemental types are represented by this type

src/AST/TypeSubstitution.hpp

@@ -30 +30 @@
 #include "Decl.hpp"
 #include "Expr.hpp"
+#include "Node.hpp"
 
 namespace ast {
@@ -43 +44 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( SynTreeClass *&input ) const;
-        template< typename SynTreeClass > int applyFree( SynTreeClass *&input ) const;
+        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
+        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
+
+        template< typename node_t, enum Node::ref_type ref_t >
+        int apply( ptr_base< node_t, ref_t > & input ) const {
+                const node_t * p = input.get();
+                int ret = apply(p);
+                input = p;
+                return ret;
+        }
+
+        template< typename node_t, enum Node::ref_type ref_t >
+        int applyFree( ptr_base< node_t, ref_t > & input ) const {
+                const node_t * p = input.get();
+                int ret = applyFree(p);
+                input = p;
+                return ret;
+        }
 
         void add( std::string formalType, const Type *actualType );
@@ -162 +179 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( SynTreeClass *&input ) const {
+int TypeSubstitution::apply( const SynTreeClass *& input ) const {
         assert( input );
         Pass<Substituter> sub( *this, false );
-        input = strict_dynamic_cast< SynTreeClass * >( input->accept( sub ) );
+        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
 ///     std::cerr << "substitution result is: ";
 ///     newType->print( std::cerr );
@@ -173 +190 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( SynTreeClass *&input ) const {
+int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
         assert( input );
         Pass<Substituter> sub( *this, true );
-        input = strict_dynamic_cast< SynTreeClass * >( input->accept( sub ) );
+        input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
 ///     std::cerr << "substitution result is: ";
 ///     newType->print( std::cerr );