Changeset 92538ab for src/AST


Ignore:
Timestamp:
Apr 10, 2022, 2:53:18 PM (4 years ago)
Author:
JiadaL <j82liang@…>
Branches:
ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum
Children:
d8e2a09
Parents:
4559b34 (diff), 6256891 (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:

Resolve conflict

Location:
src/AST
Files:
2 added
2 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    r4559b34 r92538ab  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 09 15::37::05 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  2 13:19:22 2022
    13 // Update Count     : 41
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Wed Mar 16 15:01:00 2022
     13// Update Count     : 42
    1414//
    1515
    … …  
    4949//================================================================================================
    5050namespace ast {
    51 
    52 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
    53 // allow us to use the same stratagy in the new ast.
    54 // xxx - since convert back pass works, this concern seems to be unnecessary.
    55 
    56 // these need to be accessed in new FixInit now
    57 ast::ptr<ast::Type> sizeType = nullptr;
    58 const ast::FunctionDecl * dereferenceOperator = nullptr;
    59 const ast::StructDecl   * dtorStruct = nullptr;
    60 const ast::FunctionDecl * dtorStructDestroy = nullptr;
     51// These are the shared local information used by ConverterNewToOld and
     52// ConverterOldToNew to update the global information in the two versions.
     53
     54static ast::ptr<ast::Type> sizeType = nullptr;
     55static const ast::FunctionDecl * dereferenceOperator = nullptr;
     56static const ast::StructDecl   * dtorStruct = nullptr;
     57static const ast::FunctionDecl * dtorStructDestroy = nullptr;
    6158
    6259}
    … …  
    357354        }
    358355
     356        void clausePostamble( Statement * stmt, const ast::StmtClause * node ) {
     357                stmt->location = node->location;
     358                this->node = stmt;
     359        }
     360
    359361        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
    360362                if ( inCache( node ) ) return nullptr;
    … …  
    405407                auto stmt = new SwitchStmt(
    406408                        get<Expression>().accept1( node->cond ),
    407                         get<Statement>().acceptL( node->stmts )
     409                        get<Statement>().acceptL( node->cases )
    408410                );
    409411                return stmtPostamble( stmt, node );
    410412        }
    411413
    412         const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
     414        const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
    413415                if ( inCache( node ) ) return nullptr;
    414416                auto stmt = new CaseStmt(
    … …  
    417419                        node->isDefault()
    418420                );
    419                 return stmtPostamble( stmt, node );
     421                clausePostamble( stmt, node );
     422                return nullptr;
    420423        }
    421424
    … …  
    513516        }
    514517
    515         const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
     518        const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
    516519                if ( inCache( node ) ) return nullptr;
    517520                CatchStmt::Kind kind;
    … …  
    524527                        break;
    525528                default:
    526                         assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
     529                        assertf(false, "Invalid ast::ExceptionKind: %d\n", node->kind);
    527530                }
    528531                auto stmt = new CatchStmt(
    … …  
    532535                        get<Statement>().accept1( node->body )
    533536                );
    534                 return stmtPostamble( stmt, node );
    535         }
    536 
    537         const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
     537                return clausePostamble( stmt, node ), nullptr;
     538        }
     539
     540        const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
    538541                if ( inCache( node ) ) return nullptr;
    539542                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
    540                 return stmtPostamble( stmt, node );
     543                return clausePostamble( stmt, node ), nullptr;
    541544        }
    542545
    … …  
    18941897                        old->location,
    18951898                        GET_ACCEPT_1(condition, Expr),
    1896                         GET_ACCEPT_V(statements, Stmt),
     1899                        GET_ACCEPT_V(statements, CaseClause),
    18971900                        GET_LABELS_V(old->labels)
    18981901                );
    … …  
    19021905        virtual void visit( const CaseStmt * old ) override final {
    19031906                if ( inCache( old ) ) return;
    1904                 this->node = new ast::CaseStmt(
     1907                this->node = new ast::CaseClause(
    19051908                        old->location,
    19061909                        GET_ACCEPT_1(condition, Expr),
    1907                         GET_ACCEPT_V(stmts, Stmt),
    1908                         GET_LABELS_V(old->labels)
    1909                 );
     1910                        GET_ACCEPT_V(stmts, Stmt)
     1911                );
     1912                auto labels = GET_LABELS_V(old->labels);
     1913                assertf(labels.empty(), "Labels found on CaseStmt.");
    19101914                cache.emplace( old, this->node );
    19111915        }
    … …  
    20152019                        old->location,
    20162020                        GET_ACCEPT_1(block, CompoundStmt),
    2017                         GET_ACCEPT_V(handlers, CatchStmt),
    2018                         GET_ACCEPT_1(finallyBlock, FinallyStmt),
     2021                        GET_ACCEPT_V(handlers, CatchClause),
     2022                        GET_ACCEPT_1(finallyBlock, FinallyClause),
    20192023                        GET_LABELS_V(old->labels)
    20202024                );
    … …  
    20362040                }
    20372041
    2038                 this->node = new ast::CatchStmt(
     2042                this->node = new ast::CatchClause(
    20392043                        old->location,
    20402044                        kind,
    20412045                        GET_ACCEPT_1(decl, Decl),
    20422046                        GET_ACCEPT_1(cond, Expr),
    2043                         GET_ACCEPT_1(body, Stmt),
    2044                         GET_LABELS_V(old->labels)
    2045                 );
     2047                        GET_ACCEPT_1(body, Stmt)
     2048                );
     2049                auto labels = GET_LABELS_V(old->labels);
     2050                assertf(labels.empty(), "Labels found on CatchStmt.");
    20462051                cache.emplace( old, this->node );
    20472052        }
    … …  
    20492054        virtual void visit( const FinallyStmt * old ) override final {
    20502055                if ( inCache( old ) ) return;
    2051                 this->node = new ast::FinallyStmt(
    2052                         old->location,
    2053                         GET_ACCEPT_1(block, CompoundStmt),
    2054                         GET_LABELS_V(old->labels)
    2055                 );
     2056                this->node = new ast::FinallyClause(
     2057                        old->location,
     2058                        GET_ACCEPT_1(block, CompoundStmt)
     2059                );
     2060                auto labels = GET_LABELS_V(old->labels);
     2061                assertf(labels.empty(), "Labels found on FinallyStmt.");
    20562062                cache.emplace( old, this->node );
    20572063        }
    … …  
    27182724
    27192725                for (auto & param : foralls) {
    2720                         ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
     2726                        ty->forall.emplace_back(new ast::TypeInstType(param));
    27212727                        for (auto asst : param->assertions) {
    27222728                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));

  • src/AST/Decl.cpp

    r4559b34 r92538ab  
    3939        if ( uniqueId ) return;  // ensure only set once
    4040        uniqueId = ++lastUniqueId;
    41         idMap[ uniqueId ] = this;
     41        // The extra readonly pointer is causing some reference counting issues.
     42        // idMap[ uniqueId ] = this;
    4243}
    4344
    4445readonly<Decl> Decl::fromId( UniqueId id ) {
     46        // Right now this map is always empty, so don't use it.
     47        assert( false );
    4548        IdMapType::const_iterator i = idMap.find( id );
    4649        if ( i != idMap.end() ) return i->second;
    … …  
    6568        }
    6669        for (auto & tp : this->type_params) {
    67                 ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
     70                ftype->forall.emplace_back(new TypeInstType(tp));
    6871                for (auto & ap: tp->assertions) {
    6972                        ftype->assertions.emplace_back(new VariableExpr(loc, ap));

  • src/AST/Fwd.hpp

    r4559b34 r92538ab  
    4747class ForStmt;
    4848class SwitchStmt;
    49 class CaseStmt;
     49class CaseClause;
    5050class BranchStmt;
    5151class ReturnStmt;
    5252class ThrowStmt;
    5353class TryStmt;
    54 class CatchStmt;
    55 class FinallyStmt;
     54class CatchClause;
     55class FinallyClause;
    5656class SuspendStmt;
    5757class WaitForStmt;
    … …  
    141141
    142142class TranslationUnit;
    143 // TODO: Get from the TranslationUnit:
    144 extern ptr<Type> sizeType;
    145 extern const FunctionDecl * dereferenceOperator;
    146 extern const StructDecl   * dtorStruct;
    147 extern const FunctionDecl * dtorStructDestroy;
     143class TranslationGlobal;
    148144
    149145}

  • src/AST/GenericSubstitution.cpp

    r4559b34 r92538ab  
    4545                        visit_children = false;
    4646                        const AggregateDecl * aggr = ty->aggr();
    47                         sub = TypeSubstitution{ aggr->params.begin(), aggr->params.end(), ty->params.begin() };
     47                        sub = TypeSubstitution( aggr->params, ty->params );
    4848                }
    4949

  • src/AST/Node.cpp

    r4559b34 r92538ab  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 16 14:16:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  1 09:09:39 2022
    13 // Update Count     : 3
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Mar 25 10:30:00 2022
     13// Update Count     : 4
    1414//
    1515
    … …  
    1919#include <csignal>  // MEMORY DEBUG -- for raise
    2020#include <iostream>
     21#include <utility>
    2122
    2223#include "Attribute.hpp"
    … …  
    7677void ast::ptr_base<node_t, ref_t>::_check() const {
    7778        // if(node) assert(node->was_ever_strong == false || node->strong_count > 0);
     79}
     80
     81template< typename node_t, enum ast::Node::ref_type ref_t >
     82void ast::ptr_base<node_t, ref_t>::swap( ptr_base & other ) noexcept {
     83        std::swap( this->node, other.node );
     84        _trap( this->node );
     85        _trap( other.node );
    7886}
    7987
    … …  
    152160template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::weak >;
    153161template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::strong >;
    154 template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::weak >;
    155 template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::strong >;
     162template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::weak >;
     163template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::strong >;
    156164template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::weak >;
    157165template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::strong >;
    … …  
    162170template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::weak >;
    163171template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::strong >;
    164 template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::weak >;
    165 template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::strong >;
    166 template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::weak >;
    167 template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::strong >;
     172template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::weak >;
     173template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::strong >;
     174template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
     175template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
    168176template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
    169177template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;

  • src/AST/Node.hpp

    r4559b34 r92538ab  
    1010// Created On       : Wed May 8 10:27:04 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 5 9:47:00 2020
    13 // Update Count     : 6
     12// Last Modified On : Fri Mar 25 10:33:00 2022
     13// Update Count     : 7
    1414//
    1515
    … …  
    103103
    104104/// Mutate a node field (only clones if not equal to existing value)
    105 template<typename node_t, typename parent_t, typename field_t, typename assn_t>
    106 const node_t * mutate_field( const node_t * node, field_t parent_t::* field, assn_t && val ) {
     105template<typename node_t, typename super_t, typename field_t, typename assn_t>
     106const node_t * mutate_field( const node_t * node, field_t super_t::* field, assn_t && val ) {
    107107        // skip mutate if equivalent
    108108        if ( node->*field == val ) return node;
    … …  
    115115
    116116/// Mutate a single index of a node field (only clones if not equal to existing value)
    117 template<typename node_t, typename parent_t, typename coll_t, typename ind_t, typename field_t>
     117template<typename node_t, typename super_t, typename coll_t, typename ind_t, typename field_t>
    118118const node_t * mutate_field_index(
    119         const node_t * node, coll_t parent_t::* field, ind_t i, field_t && val
     119        const node_t * node, coll_t super_t::* field, ind_t i, field_t && val
    120120) {
    121121        // skip mutate if equivalent
    … …  
    129129
    130130/// Mutate an entire indexed collection by cloning to accepted value
    131 template<typename node_t, typename parent_t, typename coll_t>
    132 const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) {
     131template<typename node_t, typename super_t, typename coll_t>
     132const node_t * mutate_each( const node_t * node, coll_t super_t::* field, Visitor & v ) {
    133133        for ( unsigned i = 0; i < (node->*field).size(); ++i ) {
    134134                node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) );
    … …  
    230230        }
    231231
     232        /// Swaps the nodes contained within two pointers.
     233        void swap( ptr_base & other ) noexcept;
     234
    232235        const node_t * get() const { _check(); return  node; }
    233236        const node_t * operator->() const { _check(); return  node; }
    … …  
    292295template< typename node_t >
    293296using readonly = ptr_base< node_t, Node::ref_type::weak >;
     297
     298/// Non-member swap that an participate in overload resolution.
     299template< typename node_t, enum Node::ref_type ref_t >
     300void swap( ptr_base< node_t, ref_t > & l, ptr_base< node_t, ref_t > & r ) {
     301        l.swap( r );
     302}
     303
    294304}
    295305

  • src/AST/Pass.hpp

    r4559b34 r92538ab  
    149149        const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
    150150        const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
    151         const ast::Stmt *             visit( const ast::CaseStmt             * ) override final;
     151        const ast::CaseClause *       visit( const ast::CaseClause           * ) override final;
    152152        const ast::Stmt *             visit( const ast::BranchStmt           * ) override final;
    153153        const ast::Stmt *             visit( const ast::ReturnStmt           * ) override final;
    154154        const ast::Stmt *             visit( const ast::ThrowStmt            * ) override final;
    155155        const ast::Stmt *             visit( const ast::TryStmt              * ) override final;
    156         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
    157         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
     156        const ast::CatchClause *      visit( const ast::CatchClause          * ) override final;
     157        const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
    158158        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
    159159        const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;

  • src/AST/Pass.impl.hpp

    r4559b34 r92538ab  
    354354                        // Take all the elements that are different in 'values'
    355355                        // and swap them into 'container'
    356                         if( values[i] != nullptr ) std::swap(container[i], values[i]);
     356                        if( values[i] != nullptr ) swap(container[i], values[i]);
    357357                }
    358358
    … …  
    399399
    400400        template< typename core_t >
    401         template<typename node_t, typename parent_t, typename child_t>
     401        template<typename node_t, typename super_t, typename field_t>
    402402        void ast::Pass< core_t >::maybe_accept(
    403403                const node_t * & parent,
    404                 child_t parent_t::*child
     404                field_t super_t::*field
    405405        ) {
    406                 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
    407 
    408                 if(__pass::skip(parent->*child)) return;
    409                 const auto & old_val = __pass::get(parent->*child, 0);
     406                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
     407
     408                if(__pass::skip(parent->*field)) return;
     409                const auto & old_val = __pass::get(parent->*field, 0);
    410410
    411411                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
    … …  
    417417                if( new_val.differs ) {
    418418                        auto new_parent = __pass::mutate<core_t>(parent);
    419                         new_val.apply(new_parent, child);
     419                        new_val.apply(new_parent, field);
    420420                        parent = new_parent;
    421421                }
    … …  
    423423
    424424        template< typename core_t >
    425         template<typename node_t, typename parent_t, typename child_t>
     425        template<typename node_t, typename super_t, typename field_t>
    426426        void ast::Pass< core_t >::maybe_accept_as_compound(
    427427                const node_t * & parent,
    428                 child_t parent_t::*child
     428                field_t super_t::*child
    429429        ) {
    430                 static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
     430                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
    431431
    432432                if(__pass::skip(parent->*child)) return;
    … …  
    893893        if ( __visit_children() ) {
    894894                maybe_accept( node, &SwitchStmt::cond  );
    895                 maybe_accept( node, &SwitchStmt::stmts );
     895                maybe_accept( node, &SwitchStmt::cases );
    896896        }
    897897
    … …  
    900900
    901901//--------------------------------------------------------------------------
    902 // CaseStmt
    903 template< typename core_t >
    904 const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
    905         VISIT_START( node );
    906 
    907         if ( __visit_children() ) {
    908                 maybe_accept( node, &CaseStmt::cond  );
    909                 maybe_accept( node, &CaseStmt::stmts );
    910         }
    911 
    912         VISIT_END( Stmt, node );
     902// CaseClause
     903template< typename core_t >
     904const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
     905        VISIT_START( node );
     906
     907        if ( __visit_children() ) {
     908                maybe_accept( node, &CaseClause::cond  );
     909                maybe_accept( node, &CaseClause::stmts );
     910        }
     911
     912        VISIT_END( CaseClause, node );
    913913}
    914914
    … …  
    964964
    965965//--------------------------------------------------------------------------
    966 // CatchStmt
    967 template< typename core_t >
    968 const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
     966// CatchClause
     967template< typename core_t >
     968const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
    969969        VISIT_START( node );
    970970
    … …  
    972972                // catch statements introduce a level of scope (for the caught exception)
    973973                guard_symtab guard { *this };
    974                 maybe_accept( node, &CatchStmt::decl );
    975                 maybe_accept( node, &CatchStmt::cond );
    976                 maybe_accept_as_compound( node, &CatchStmt::body );
    977         }
    978 
    979         VISIT_END( Stmt, node );
    980 }
    981 
    982 //--------------------------------------------------------------------------
    983 // FinallyStmt
    984 template< typename core_t >
    985 const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
    986         VISIT_START( node );
    987 
    988         if ( __visit_children() ) {
    989                 maybe_accept( node, &FinallyStmt::body );
    990         }
    991 
    992         VISIT_END( Stmt, node );
     974                maybe_accept( node, &CatchClause::decl );
     975                maybe_accept( node, &CatchClause::cond );
     976                maybe_accept_as_compound( node, &CatchClause::body );
     977        }
     978
     979        VISIT_END( CatchClause, node );
     980}
     981
     982//--------------------------------------------------------------------------
     983// FinallyClause
     984template< typename core_t >
     985const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
     986        VISIT_START( node );
     987
     988        if ( __visit_children() ) {
     989                maybe_accept( node, &FinallyClause::body );
     990        }
     991
     992        VISIT_END( FinallyClause, node );
    993993}
    994994
    … …  
    10541054                        auto n = __pass::mutate<core_t>(node);
    10551055                        for(size_t i = 0; i < new_clauses.size(); i++) {
    1056                                 if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
     1056                                if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
    10571057
    10581058                                for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
    1059                                         if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
     1059                                        if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
    10601060                                }
    10611061
    1062                                 if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
    1063                                 if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
     1062                                if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
     1063                                if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
    10641064                        }
    10651065                        node = n;
    … …  
    21512151
    21522152        if ( __visit_children() ) {
    2153                 {
    2154                         bool mutated = false;
    2155                         std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
    2156                         for ( const auto & p : node->typeEnv ) {
    2157                                 guard_symtab guard { *this };
    2158                                 auto new_node = p.second->accept( *this );
    2159                                 if (new_node != p.second) mutated = true;
    2160                                 new_map.insert({ p.first, new_node });
    2161                         }
    2162                         if (mutated) {
    2163                                 auto new_node = __pass::mutate<core_t>( node );
    2164                                 new_node->typeEnv.swap( new_map );
    2165                                 node = new_node;
    2166                         }
     2153                bool mutated = false;
     2154                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
     2155                for ( const auto & p : node->typeEnv ) {
     2156                        guard_symtab guard { *this };
     2157                        auto new_node = p.second->accept( *this );
     2158                        if (new_node != p.second) mutated = true;
     2159                        new_map.insert({ p.first, new_node });
     2160                }
     2161                if (mutated) {
     2162                        auto new_node = __pass::mutate<core_t>( node );
     2163                        new_node->typeEnv.swap( new_map );
     2164                        node = new_node;
    21672165                }
    21682166        }

  • src/AST/Print.cpp

    r4559b34 r92538ab  
    597597
    598598                ++indent;
    599                 for ( const ast::Stmt * stmt : node->stmts ) {
     599                for ( const ast::CaseClause * stmt : node->cases ) {
    600600                        stmt->accept( *this );
    601601                }
    … …  
    605605        }
    606606
    607         virtual const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
     607        virtual const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
    608608                if ( node->isDefault() ) {
    609609                        os << indent << "Default ";
    … …  
    687687
    688688                os << indent-1 << "... and handlers:" << endl;
    689                 for ( const ast::CatchStmt * stmt : node->handlers ) {
     689                for ( const ast::CatchClause * stmt : node->handlers ) {
    690690                        os << indent;
    691691                        stmt->accept( *this );
    … …  
    701701        }
    702702
    703         virtual const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
     703        virtual const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
    704704                os << "Catch ";
    705705                switch ( node->kind ) {
    … …  
    726726        }
    727727
    728         virtual const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
     728        virtual const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
    729729                os << "Finally Statement" << endl;
    730730                os << indent << "... with block:" << endl;

  • src/AST/Stmt.hpp

    r4559b34 r92538ab  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May  8 13:00:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb  2 20:06:41 2022
    13 // Update Count     : 34
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Mon Mar 28  9:50:00 2022
     13// Update Count     : 35
    1414//
    1515
    … …  
    4747  private:
    4848        Stmt * clone() const override = 0;
     49        MUTATE_FRIEND
     50};
     51
     52// Base statement component node (only serves to group them).
     53class StmtClause : public ParseNode {
     54  public:
     55        // This is for non-statements that still belong with the statements,
     56        // but are not statements, usually some sort of clause. Often these can
     57        // (and should) be folded into the approprate parent node, but if they
     58        // cannot be, they are sub-types of this type, for organization.
     59
     60    StmtClause( const CodeLocation & loc )
     61                : ParseNode(loc) {}
     62
     63  private:
     64        StmtClause * clone() const override = 0;
    4965        MUTATE_FRIEND
    5066};
    … …  
    158174  public:
    159175        ptr<Expr> cond;
     176        std::vector<ptr<CaseClause>> cases;
     177
     178        SwitchStmt( const CodeLocation & loc, const Expr * cond,
     179                                const std::vector<ptr<CaseClause>> && cases,
     180                                const std::vector<Label> && labels = {} )
     181                : Stmt(loc, std::move(labels)), cond(cond), cases(std::move(cases)) {}
     182
     183        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     184  private:
     185        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
     186        MUTATE_FRIEND
     187};
     188
     189// Case label: case ...: or default:
     190class CaseClause final : public StmtClause {
     191  public:
     192        // Null for the default label.
     193        ptr<Expr> cond;
    160194        std::vector<ptr<Stmt>> stmts;
    161195
    162         SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
    163                                 const std::vector<Label> && labels = {} )
    164                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    165 
    166         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    167   private:
    168         SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
    169         MUTATE_FRIEND
    170 };
    171 
    172 // Case label: case ...: or default:
    173 class CaseStmt final : public Stmt {
    174   public:
    175         // Null for the default label.
    176         ptr<Expr> cond;
    177         std::vector<ptr<Stmt>> stmts;
    178 
    179         CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
    180                           const std::vector<Label> && labels = {} )
    181                 : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
     196        CaseClause( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts )
     197                : StmtClause(loc), cond(cond), stmts(std::move(stmts)) {}
    182198
    183199        bool isDefault() const { return !cond; }
    184200
    185         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    186   private:
    187         CaseStmt * clone() const override { return new CaseStmt{ *this }; }
     201        const CaseClause * accept( Visitor & v ) const override { return v.visit( this ); }
     202  private:
     203        CaseClause * clone() const override { return new CaseClause{ *this }; }
    188204        MUTATE_FRIEND
    189205};
    … …  
    298314  public:
    299315        ptr<CompoundStmt> body;
    300         std::vector<ptr<CatchStmt>> handlers;
    301         ptr<FinallyStmt> finally;
     316        std::vector<ptr<CatchClause>> handlers;
     317        ptr<FinallyClause> finally;
    302318
    303319        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
    304                          const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
     320                         const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
    305321                         const std::vector<Label> && labels = {} )
    306322                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
    … …  
    313329
    314330// Catch clause of try statement
    315 class CatchStmt final : public Stmt {
     331class CatchClause final : public StmtClause {
    316332  public:
    317333        ptr<Decl> decl;
    … …  
    320336        ExceptionKind kind;
    321337
    322         CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
    323                            const Stmt * body, const std::vector<Label> && labels = {} )
    324                 : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
    325 
    326         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    327   private:
    328         CatchStmt * clone() const override { return new CatchStmt{ *this }; }
     338        CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
     339                           const Stmt * body )
     340                : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
     341
     342        const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
     343  private:
     344        CatchClause * clone() const override { return new CatchClause{ *this }; }
    329345        MUTATE_FRIEND
    330346};
    331347
    332348// Finally clause of try statement
    333 class FinallyStmt final : public Stmt {
     349class FinallyClause final : public StmtClause {
    334350  public:
    335351        ptr<CompoundStmt> body;
    336352
    337         FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
    338                                  std::vector<Label> && labels = {} )
    339                 : Stmt(loc, std::move(labels)), body(body) {}
    340 
    341         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    342   private:
    343         FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
     353        FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
     354                : StmtClause(loc), body(body) {}
     355
     356        const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
     357  private:
     358        FinallyClause * clone() const override { return new FinallyClause{ *this }; }
    344359        MUTATE_FRIEND
    345360};

  • src/AST/TranslationUnit.hpp

    r4559b34 r92538ab  
    1010// Created On       : Tue Jun 11 15:30:00 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jun 11 15:42:00 2019
    13 // Update Count     : 0
     12// Last Modified On : Tue Mar 11 11:19:00 2022
     13// Update Count     : 1
    1414//
    1515
    … …  
    2323namespace ast {
    2424
     25class TranslationGlobal {
     26public:
     27        std::map< UniqueId, Decl * > idMap;
     28
     29        ptr<Type> sizeType;
     30        const FunctionDecl * dereference;
     31        const StructDecl * dtorStruct;
     32        const FunctionDecl * dtorDestroy;
     33};
     34
    2535class TranslationUnit {
    2636public:
    2737        std::list< ptr< Decl > > decls;
    28 
    29         struct Global {
    30                 std::map< UniqueId, Decl * > idMap;
    31 
    32                 ptr<Type> sizeType;
    33                 const FunctionDecl * dereference;
    34                 const StructDecl * dtorStruct;
    35                 const FunctionDecl * dtorDestroy;
    36         } global;
     38        TranslationGlobal global;
    3739};
    3840

  • src/AST/Type.cpp

    r4559b34 r92538ab  
    147147// --- TypeInstType
    148148
     149TypeInstType::TypeInstType( const TypeDecl * b,
     150        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
     151: BaseInstType( b->name, q, move(as) ), base( b ), kind( b->kind ) {}
     152
    149153void TypeInstType::set_base( const TypeDecl * b ) {
    150154        base = b;

  • src/AST/Type.hpp

    r4559b34 r92538ab  
    421421                std::vector<ptr<Attribute>> && as = {} )
    422422        : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
     423
     424        TypeInstType( const TypeDecl * b,
     425                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
     426
    423427        TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
    424428                std::vector<ptr<Attribute>> && as = {} )

  • src/AST/TypeSubstitution.hpp

    r4559b34 r92538ab  
    3737  public:
    3838        TypeSubstitution();
     39        template< typename FormalContainer, typename ActualContainer >
     40        TypeSubstitution( FormalContainer formals, ActualContainer actuals );
    3941        template< typename FormalIterator, typename ActualIterator >
    4042        TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
    … …  
    7678        bool empty() const;
    7779
     80        template< typename FormalContainer, typename ActualContainer >
     81        void addAll( FormalContainer formals, ActualContainer actuals );
    7882        template< typename FormalIterator, typename ActualIterator >
    79         void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
     83        void addAll( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
    8084
    8185        /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
    … …  
    112116};
    113117
     118template< typename FormalContainer, typename ActualContainer >
     119TypeSubstitution::TypeSubstitution( FormalContainer formals, ActualContainer actuals ) {
     120        assert( formals.size() == actuals.size() );
     121        addAll( formals.begin(), formals.end(), actuals.begin() );
     122}
     123
     124template< typename FormalIterator, typename ActualIterator >
     125TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
     126        addAll( formalBegin, formalEnd, actualBegin );
     127}
     128
     129template< typename FormalContainer, typename ActualContainer >
     130void TypeSubstitution::addAll( FormalContainer formals, ActualContainer actuals ) {
     131        assert( formals.size() == actuals.size() );
     132        addAll( formals.begin(), formals.end(), actuals.begin() );
     133}
     134
    114135// this is the only place where type parameters outside a function formal may be substituted.
    115136template< typename FormalIterator, typename ActualIterator >
    116 void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
     137void TypeSubstitution::addAll( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
    117138        // FormalIterator points to a TypeDecl
    118139        // ActualIterator points to a Type
    … …  
    129150                        } // if
    130151                } else {
    131                        
     152                        // Is this an error?
    132153                } // if
    133154        } // for
    134155}
    135 
    136 
    137 
    138 template< typename FormalIterator, typename ActualIterator >
    139 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
    140         add( formalBegin, formalEnd, actualBegin );
    141 }
    142 
    143156
    144157} // namespace ast

  • src/AST/Visitor.hpp

    r4559b34 r92538ab  
    4141    virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
    4242    virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
    43     virtual const ast::Stmt *             visit( const ast::CaseStmt             * ) = 0;
     43    virtual const ast::CaseClause *       visit( const ast::CaseClause           * ) = 0;
    4444    virtual const ast::Stmt *             visit( const ast::BranchStmt           * ) = 0;
    4545    virtual const ast::Stmt *             visit( const ast::ReturnStmt           * ) = 0;
    4646    virtual const ast::Stmt *             visit( const ast::ThrowStmt            * ) = 0;
    4747    virtual const ast::Stmt *             visit( const ast::TryStmt              * ) = 0;
    48     virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
    49     virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
     48    virtual const ast::CatchClause *      visit( const ast::CatchClause          * ) = 0;
     49    virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
    5050    virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
    5151    virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;

  • src/AST/module.mk

    r4559b34 r92538ab  
    1616
    1717SRC_AST = \
    18         AST/AssertAcyclic.cpp \
    19         AST/AssertAcyclic.hpp \
    2018        AST/Attribute.cpp \
    2119        AST/Attribute.hpp \
    … …  
    6462        AST/TypeSubstitution.cpp \
    6563        AST/TypeSubstitution.hpp \
     64        AST/Util.cpp \
     65        AST/Util.hpp \
    6666        AST/Visitor.hpp
    6767
Note: See TracChangeset for help on using the changeset viewer.