Changeset e7f8119 for src/AST

Timestamp:

Jun 10, 2019, 10:52:03 AM (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:

6355ba7

Parents:

9856ca9 (diff), 61c7239 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/AST

Files:

• Convert.cpp (modified) (6 diffs)
• Expr.cpp (modified) (1 diff)
• Expr.hpp (modified) (5 diffs)
• GenericSubstitution.cpp (modified) (2 diffs)
• GenericSubstitution.hpp (modified) (1 diff)
• Init.hpp (modified) (2 diffs)
• Node.hpp (modified) (4 diffs)
• porting.md (modified) (1 diff)

src/AST/Convert.cpp

@@ -16 +16 @@
 #include "Convert.hpp"
 
+#include <deque>
 #include <unordered_map>
 
@@ -575 +576 @@
 
                 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
-                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
+                        const ast::InferredParams &srcParams = srcInferred.inferParams();
                         for (auto srcParam : srcParams) {
                                 tgtInferParams[srcParam.first] = ParamEntry(
@@ -585 +586 @@
                         }
                 } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
-                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
+                        const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
                         for (auto srcSlot : srcSlots) {
                                 tgtResnSlots.push_back(srcSlot);
@@ -1421 +1422 @@
 #       define GET_ACCEPT_V(child, type) \
                 getAcceptV< ast::type, decltype( old->child ) >( old->child )
+        
+        template<typename NewT, typename OldC>
+        std::deque< ast::ptr<NewT> > getAcceptD( OldC& old ) {
+                std::deque< ast::ptr<NewT> > ret;
+                for ( auto a : old ) {
+                        a->accept( *this );
+                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
+                        node = nullptr;
+                }
+                return ret;
+        }
+
+#       define GET_ACCEPT_D(child, type) \
+                getAcceptD< ast::type, decltype( old->child ) >( old->child )
 
         ast::Label make_label(Label* old) {
@@ -2462 +2477 @@
 
         virtual void visit( UntypedInitExpr * old ) override final {
-                std::vector<ast::InitAlternative> initAlts;
+                std::deque<ast::InitAlternative> initAlts;
                 for (auto ia : old->initAlts) {
                         initAlts.push_back(ast::InitAlternative(
@@ -2727 +2742 @@
                 this->node = new ast::Designation(
                         old->location,
-                        GET_ACCEPT_V(designators, Expr)
+                        GET_ACCEPT_D(designators, Expr)
                 );
         }

src/AST/Expr.cpp

@@ -163 +163 @@
         result = mem->get_type();
         // substitute aggregate generic parameters into member type
-        genericSubsitution( aggregate->result ).apply( result );
+        genericSubstitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
         add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );

src/AST/Expr.hpp

@@ -17 +17 @@
 
 #include <cassert>
+#include <deque>
 #include <map>
 #include <string>
@@ -111 +112 @@
                 }
 
-                const ResnSlots& resnSlotsConst() const {
+                const ResnSlots& resnSlots() const {
                         if (mode == Slots) {
                                 return data.resnSlots;
@@ -128 +129 @@
                 }
 
-                const InferredParams& inferParamsConst() const {
+                const InferredParams& inferParams() const {
                         if (mode == Params) {
                                 return data.inferParams;
@@ -134 +135 @@
                         assert(!"Mode was not already Params");
                         return *((InferredParams*)nullptr);
+                }
+
+                /// splices other InferUnion into this one. Will fail if one union is in `Slots` mode 
+                /// and the other is in `Params`.
+                void splice( InferUnion && o ) {
+                        if ( o.mode == Empty ) return;
+                        if ( mode == Empty ) { init_from( o ); return; }
+                        assert( mode == o.mode && "attempt to splice incompatible InferUnion" );
+
+                        if ( mode == Slots ){
+                                data.resnSlots.insert( 
+                                        data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() );
+                        } else if ( mode == Params ) {
+                                for ( const auto & p : o.data.inferParams ) {
+                                        data.inferParams[p.first] = std::move(p.second);
+                                }
+                        } else assert(!"invalid mode");
                 }
         };
@@ -695 +713 @@
 public:
         ptr<Expr> expr;
-        std::vector<InitAlternative> initAlts;
-
-        UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::vector<InitAlternative> && as )
+        std::deque<InitAlternative> initAlts;
+
+        UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::deque<InitAlternative> && as )
         : Expr( loc ), expr( e ), initAlts( std::move(as) ) {}
 

src/AST/GenericSubstitution.cpp

@@ -31 +31 @@
                 TypeSubstitution sub;
 
-                void previsit( const Type * ty ) {
-                        assertf( false, "Attempted generic substitution for non-aggregate type: %s",
-                                toString( ty ).c_str() );
+                void previsit( const Type * ) {
+                        // allow empty substitution for non-generic type
+                        visit_children = false;
                 }
 
@@ -40 +40 @@
                 }
 
-                void previsit( const ReferenceToType * ty ) {
+        private:
+                // make substitution for generic type
+                void makeSub( 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() };
+                }
+
+        public:
+                void previsit( const StructInstType * ty ) {
+                        makeSub( ty );
+                }
+
+                void previsit( const UnionInstType * ty ) {
+                        makeSub( ty );
                 }
         };
 }
 
-TypeSubstitution genericSubsitution( const Type * ty ) {
+TypeSubstitution genericSubstitution( const Type * ty ) {
         Pass<GenericSubstitutionBuilder> builder;
         maybe_accept( ty, builder );

src/AST/GenericSubstitution.hpp

@@ -22 +22 @@
 class Type;
 
-TypeSubstitution genericSubsitution( const Type * );
+TypeSubstitution genericSubstitution( const Type * );
 
 }

src/AST/Init.hpp

@@ -16 +16 @@
 #pragma once
 
+#include <deque>
 #include <utility>        // for move
 #include <vector>
@@ -35 +36 @@
 class Designation final : public ParseNode {
 public:
-        std::vector<ptr<Expr>> designators;
+        std::deque<ptr<Expr>> designators;
 
-        Designation( const CodeLocation& loc, std::vector<ptr<Expr>>&& ds = {} )
+        Designation( const CodeLocation& loc, std::deque<ptr<Expr>>&& ds = {} )
         : ParseNode( loc ), designators( std::move(ds) ) {}
 

src/AST/Node.hpp

@@ -154 +154 @@
 
         template< enum Node::ref_type o_ref_t >
-        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
+        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.get()) {
                 if( node ) _inc(node);
         }
 
         template< enum Node::ref_type o_ref_t >
-        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
+        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.get()) {
                 if( node ) _inc(node);
         }
@@ -184 +184 @@
         template< enum Node::ref_type o_ref_t >
         ptr_base & operator=( const ptr_base<node_t, o_ref_t> & o ) {
-                assign(o.node);
+                assign(o.get());
                 return *this;
         }
@@ -190 +190 @@
         template< enum Node::ref_type o_ref_t >
         ptr_base & operator=( ptr_base<node_t, o_ref_t> && o ) {
-                assign(o.node);
+                assign(o.get());
                 return *this;
         }
@@ -228 +228 @@
         void _check() const;
 
-protected:
         const node_t * node;
 };

src/AST/porting.md

@@ -238 +238 @@
     * also now returns `const AggregateDecl *`
 * `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp`
+  * subsumes old `makeGenericSubstitution()`
 
 `BasicType`