Changeset 2e9b59b for src/AST

Timestamp:

Apr 19, 2022, 3:00:04 PM (4 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

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

Children:

5b84a321

Parents:

ba897d21 (diff), bb7c77d (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:

added benchmark and evaluations chapter to thesis

Location:

src/AST

Files:

• Convert.cpp (modified) (25 diffs)
• Decl.cpp (modified) (2 diffs)
• Decl.hpp (modified) (2 diffs)
• Expr.hpp (modified) (1 diff)
• Fwd.hpp (modified) (3 diffs)
• GenericSubstitution.cpp (modified) (1 diff)
• Node.cpp (modified) (5 diffs)
• Node.hpp (modified) (6 diffs)
• Pass.hpp (modified) (2 diffs)
• Pass.impl.hpp (modified) (13 diffs)
• Pass.proto.hpp (modified) (3 diffs)
• Print.cpp (modified) (7 diffs)
• Stmt.hpp (modified) (6 diffs)
• TranslationUnit.hpp (modified) (2 diffs)
• Type.cpp (modified) (1 diff)
• Type.hpp (modified) (1 diff)
• TypeSubstitution.hpp (modified) (4 diffs)
• Util.cpp (modified) (2 diffs)
• Visitor.hpp (modified) (2 diffs)

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 13:19:22 2022
-// Update Count     : 41
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Mar 16 15:01:00 2022
+// Update Count     : 42
 //
 
@@ -49 +49 @@
 //================================================================================================
 namespace ast {
-
-// This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
-// allow us to use the same stratagy in the new ast.
-// xxx - since convert back pass works, this concern seems to be unnecessary.
-
-// these need to be accessed in new FixInit now
-ast::ptr<ast::Type> sizeType = nullptr;
-const ast::FunctionDecl * dereferenceOperator = nullptr;
-const ast::StructDecl   * dtorStruct = nullptr;
-const ast::FunctionDecl * dtorStructDestroy = nullptr;
+// These are the shared local information used by ConverterNewToOld and
+// ConverterOldToNew to update the global information in the two versions.
+
+static ast::ptr<ast::Type> sizeType = nullptr;
+static const ast::FunctionDecl * dereferenceOperator = nullptr;
+static const ast::StructDecl   * dtorStruct = nullptr;
+static const ast::FunctionDecl * dtorStructDestroy = nullptr;
 
 }
@@ -276 +273 @@
                 decl->parent = get<AggregateDecl>().accept1( node->parent );
                 declPostamble( decl, node );
-                return nullptr;
+                return nullptr; // ??
         }
 
@@ -310 +307 @@
                         node->name,
                         get<Attribute>().acceptL( node->attributes ),
-                        LinkageSpec::Spec( node->linkage.val )
-                );
-                return aggregatePostamble( decl, node );
+                        LinkageSpec::Spec( node->linkage.val ),
+                        get<Type>().accept1(node->base)
+                );
+                return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble
         }
 
@@ -354 +352 @@
                 this->node = stmt;
                 return nullptr;
+        }
+
+        void clausePostamble( Statement * stmt, const ast::StmtClause * node ) {
+                stmt->location = node->location;
+                this->node = stmt;
         }
 
@@ -404 +407 @@
                 auto stmt = new SwitchStmt(
                         get<Expression>().accept1( node->cond ),
-                        get<Statement>().acceptL( node->stmts )
+                        get<Statement>().acceptL( node->cases )
                 );
                 return stmtPostamble( stmt, node );
         }
 
-        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+        const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new CaseStmt(
@@ -416 +419 @@
                         node->isDefault()
                 );
-                return stmtPostamble( stmt, node );
+                clausePostamble( stmt, node );
+                return nullptr;
         }
 
@@ -512 +516 @@
         }
 
-        const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
+        const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
                 if ( inCache( node ) ) return nullptr;
                 CatchStmt::Kind kind;
@@ -523 +527 @@
                         break;
                 default:
-                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
+                        assertf(false, "Invalid ast::ExceptionKind: %d\n", node->kind);
                 }
                 auto stmt = new CatchStmt(
@@ -531 +535 @@
                         get<Statement>().accept1( node->body )
                 );
-                return stmtPostamble( stmt, node );
-        }
-
-        const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
+                return clausePostamble( stmt, node ), nullptr;
+        }
+
+        const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
-                return stmtPostamble( stmt, node );
+                return clausePostamble( stmt, node ), nullptr;
         }
 
@@ -947 +951 @@
         }
 
+        const ast::Expr * visit( const ast::DimensionExpr * node ) override final {
+                auto expr = visitBaseExpr( node, new DimensionExpr( node->name ) );
+                this->node = expr;
+                return nullptr;
+        }
+
         const ast::Expr * visit( const ast::AsmExpr * node ) override final {
                 auto expr = visitBaseExpr( node,
@@ -1467 +1477 @@
                 return strict_dynamic_cast< ast::Decl * >( node );
         }
-
+        
         ConverterOldToNew() = default;
         ConverterOldToNew(const ConverterOldToNew &) = delete;
@@ -1495 +1505 @@
                 getAccept1< ast::type, decltype( old->child ) >( old->child )
 
+
         template<typename NewT, typename OldC>
         std::vector< ast::ptr<NewT> > getAcceptV( const OldC& old ) {
@@ -1509 +1520 @@
 #       define GET_ACCEPT_V(child, type) \
                 getAcceptV< ast::type, decltype( old->child ) >( old->child )
+
+#       define GET_ACCEPT_E(child, type) \
+                getAccept1< ast::type, decltype( old->base ) >( old->base )
 
         template<typename NewT, typename OldC>
@@ -1710 +1724 @@
         }
 
+        // Convert SynTree::EnumDecl to AST::EnumDecl
         virtual void visit( const EnumDecl * old ) override final {
                 if ( inCache( old ) ) return;
@@ -1716 +1731 @@
                         old->name,
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->linkage.val }
+                        { old->linkage.val },
+                        GET_ACCEPT_1(base, Type),
+                        old->enumValues
                 );
                 cache.emplace( old, decl );
@@ -1726 +1743 @@
                 decl->uniqueId   = old->uniqueId;
                 decl->storage    = { old->storageClasses.val };
-
                 this->node = decl;
         }
@@ -1887 +1903 @@
                         old->location,
                         GET_ACCEPT_1(condition, Expr),
-                        GET_ACCEPT_V(statements, Stmt),
+                        GET_ACCEPT_V(statements, CaseClause),
                         GET_LABELS_V(old->labels)
                 );
@@ -1895 +1911 @@
         virtual void visit( const CaseStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                this->node = new ast::CaseStmt(
+                this->node = new ast::CaseClause(
                         old->location,
                         GET_ACCEPT_1(condition, Expr),
-                        GET_ACCEPT_V(stmts, Stmt),
-                        GET_LABELS_V(old->labels)
-                );
+                        GET_ACCEPT_V(stmts, Stmt)
+                );
+                auto labels = GET_LABELS_V(old->labels);
+                assertf(labels.empty(), "Labels found on CaseStmt.");
                 cache.emplace( old, this->node );
         }
@@ -2008 +2025 @@
                         old->location,
                         GET_ACCEPT_1(block, CompoundStmt),
-                        GET_ACCEPT_V(handlers, CatchStmt),
-                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
+                        GET_ACCEPT_V(handlers, CatchClause),
+                        GET_ACCEPT_1(finallyBlock, FinallyClause),
                         GET_LABELS_V(old->labels)
                 );
@@ -2029 +2046 @@
                 }
 
-                this->node = new ast::CatchStmt(
+                this->node = new ast::CatchClause(
                         old->location,
                         kind,
                         GET_ACCEPT_1(decl, Decl),
                         GET_ACCEPT_1(cond, Expr),
-                        GET_ACCEPT_1(body, Stmt),
-                        GET_LABELS_V(old->labels)
-                );
+                        GET_ACCEPT_1(body, Stmt)
+                );
+                auto labels = GET_LABELS_V(old->labels);
+                assertf(labels.empty(), "Labels found on CatchStmt.");
                 cache.emplace( old, this->node );
         }
@@ -2042 +2060 @@
         virtual void visit( const FinallyStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                this->node = new ast::FinallyStmt(
-                        old->location,
-                        GET_ACCEPT_1(block, CompoundStmt),
-                        GET_LABELS_V(old->labels)
-                );
+                this->node = new ast::FinallyClause(
+                        old->location,
+                        GET_ACCEPT_1(block, CompoundStmt)
+                );
+                auto labels = GET_LABELS_V(old->labels);
+                assertf(labels.empty(), "Labels found on FinallyStmt.");
                 cache.emplace( old, this->node );
         }
@@ -2450 +2469 @@
 
         virtual void visit( const DimensionExpr * old ) override final {
-                // DimensionExpr gets desugared away in Validate.
-                // As long as new-AST passes don't use it, this cheap-cheerful error
-                // detection helps ensure that these occurrences have been compiled
-                // away, as expected.  To move the DimensionExpr boundary downstream
-                // or move the new-AST translation boundary upstream, implement
-                // DimensionExpr in the new AST and implement a conversion.
-                (void) old;
-                assert(false && "DimensionExpr should not be present at new-AST boundary");
+                this->node = visitBaseExpr( old,
+                        new ast::DimensionExpr( old->location, old->name )
+                );
         }
 
@@ -2711 +2725 @@
 
                 for (auto & param : foralls) {
-                        ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
+                        ty->forall.emplace_back(new ast::TypeInstType(param));
                         for (auto asst : param->assertions) {
                                 ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
@@ -2761 +2775 @@
         }
 
-        virtual void visit( const EnumInstType * old ) override final {
-                ast::EnumInstType * ty;
+        virtual void visit( const EnumInstType * old ) override final { // Here is visiting the EnumInst Decl not the usage.
+                ast::EnumInstType * ty; 
                 if ( old->baseEnum ) {
-                        ty = new ast::EnumInstType{
+                        ty = new ast::EnumInstType{ // Probably here: missing the specification of the base
                                 GET_ACCEPT_1( baseEnum, EnumDecl ),
                                 cv( old ),

src/AST/Decl.cpp

@@ -68 +68 @@
         }
         for (auto & tp : this->type_params) {
-                ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
+                ftype->forall.emplace_back(new TypeInstType(tp));
                 for (auto & ap: tp->assertions) {
                         ftype->assertions.emplace_back(new VariableExpr(loc, ap));
@@ -136 +136 @@
 
         auto it = enumValues.find( enumerator->name );
+        
         if ( it != enumValues.end() ) {
-                value = it->second;
+                        
+                // Handle typed enum by casting the value in (C++) compiler
+                // if ( base ) { // A typed enum
+                //      if ( const BasicType * bt = dynamic_cast<const BasicType *>(base) ) {
+                //              switch( bt->kind ) {
+                //                      case BasicType::Kind::Bool:     value = (bool) it->second; break;
+                //                      case BasicType::Kind::Char: value = (char) it->second; break;
+                //                      case BasicType::Kind::SignedChar: value = (signed char) it->second; break;
+                //                      case BasicType::Kind::UnsignedChar: value = (unsigned char) it->second; break;
+                //                      case BasicType::Kind::ShortSignedInt: value = (short signed int) it->second; break;
+                //                      case BasicType::Kind::SignedInt: value = (signed int) it->second; break;
+                //                      case BasicType::Kind::UnsignedInt: value = (unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongSignedInt: value = (long signed int) it->second; break;
+                //                      case BasicType::Kind::LongUnsignedInt: value = (long unsigned int) it->second; break;
+                //                      case BasicType::Kind::LongLongSignedInt: value = (long long signed int) it->second; break;
+                //                      case BasicType::Kind::LongLongUnsignedInt: value = (long long unsigned int) it->second; break; 
+                //                      // TODO: value should be able to handle long long unsigned int
+
+                //                      default:
+                //                      value = it->second;
+                //              }
+                //      }
+                // } else {
+                        value = it->second;
+                //}
+
                 return true;
         }

src/AST/Decl.hpp

@@ -302 +302 @@
 class EnumDecl final : public AggregateDecl {
 public:
+        ptr<Type> base;
+
         EnumDecl( const CodeLocation& loc, const std::string& name,
-                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
-        : AggregateDecl( loc, name, std::move(attrs), linkage ), enumValues() {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall, Type * base = nullptr,
+                 std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), base(base), enumValues(enumValues) {}
 
         /// gets the integer value for this enumerator, returning true iff value found
+        // Maybe it is not used in producing the enum value
         bool valueOf( const Decl * enumerator, long long& value ) const;
 
@@ -312 +316 @@
 
         const char * typeString() const override { return aggrString( Enum ); }
+
+        bool isTyped() {return base && base.get();}
 
 private:

src/AST/Expr.hpp

@@ -604 +604 @@
 };
 
+class DimensionExpr final : public Expr {
+public:
+        std::string name;
+
+        DimensionExpr( const CodeLocation & loc, std::string name )
+        : Expr( loc ), name( name ) {}
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DimensionExpr * clone() const override { return new DimensionExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// A GCC "asm constraint operand" used in an asm statement, e.g. `[output] "=f" (result)`.
 /// https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints

src/AST/Fwd.hpp

@@ -47 +47 @@
 class ForStmt;
 class SwitchStmt;
-class CaseStmt;
+class CaseClause;
 class BranchStmt;
 class ReturnStmt;
 class ThrowStmt;
 class TryStmt;
-class CatchStmt;
-class FinallyStmt;
+class CatchClause;
+class FinallyClause;
 class SuspendStmt;
 class WaitForStmt;
@@ -84 +84 @@
 class CommaExpr;
 class TypeExpr;
+class DimensionExpr;
 class AsmExpr;
 class ImplicitCopyCtorExpr;
@@ -141 +142 @@
 
 class TranslationUnit;
-// TODO: Get from the TranslationUnit:
-extern ptr<Type> sizeType;
-extern const FunctionDecl * dereferenceOperator;
-extern const StructDecl   * dtorStruct;
-extern const FunctionDecl * dtorStructDestroy;
+class TranslationGlobal;
 
 }

src/AST/GenericSubstitution.cpp

@@ -45 +45 @@
                         visit_children = false;
                         const AggregateDecl * aggr = ty->aggr();
-                        sub = TypeSubstitution{ aggr->params.begin(), aggr->params.end(), ty->params.begin() };
+                        sub = TypeSubstitution( aggr->params, ty->params );
                 }
 

src/AST/Node.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 16 14:16:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 09:09:39 2022
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 25 10:30:00 2022
+// Update Count     : 4
 //
 
@@ -19 +19 @@
 #include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
+#include <utility>
 
 #include "Attribute.hpp"
@@ -76 +77 @@
 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 >
+void ast::ptr_base<node_t, ref_t>::swap( ptr_base & other ) noexcept {
+        std::swap( this->node, other.node );
+        _trap( this->node );
+        _trap( other.node );
 }
 
@@ -152 +160 @@
 template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::SwitchStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::CaseStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::CaseClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::BranchStmt, ast::Node::ref_type::strong >;
@@ -162 +170 @@
 template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::TryStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::CatchStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::FinallyStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::CatchClause, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::FinallyClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Jun 5 9:47:00 2020
-// Update Count     : 6
+// Last Modified On : Fri Mar 25 10:33:00 2022
+// Update Count     : 7
 //
 
@@ -103 +103 @@
 
 /// Mutate a node field (only clones if not equal to existing value)
-template<typename node_t, typename parent_t, typename field_t, typename assn_t>
-const node_t * mutate_field( const node_t * node, field_t parent_t::* field, assn_t && val ) {
+template<typename node_t, typename super_t, typename field_t, typename assn_t>
+const node_t * mutate_field( const node_t * node, field_t super_t::* field, assn_t && val ) {
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
@@ -115 +115 @@
 
 /// Mutate a single index of a node field (only clones if not equal to existing value)
-template<typename node_t, typename parent_t, typename coll_t, typename ind_t, typename field_t>
+template<typename node_t, typename super_t, typename coll_t, typename ind_t, typename field_t>
 const node_t * mutate_field_index(
-        const node_t * node, coll_t parent_t::* field, ind_t i, field_t && val
+        const node_t * node, coll_t super_t::* field, ind_t i, field_t && val
 ) {
         // skip mutate if equivalent
@@ -129 +129 @@
 
 /// Mutate an entire indexed collection by cloning to accepted value
-template<typename node_t, typename parent_t, typename coll_t>
-const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) {
+template<typename node_t, typename super_t, typename coll_t>
+const node_t * mutate_each( const node_t * node, coll_t super_t::* field, Visitor & v ) {
         for ( unsigned i = 0; i < (node->*field).size(); ++i ) {
                 node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) );
@@ -230 +230 @@
         }
 
+        /// Swaps the nodes contained within two pointers.
+        void swap( ptr_base & other ) noexcept;
+
         const node_t * get() const { _check(); return  node; }
         const node_t * operator->() const { _check(); return  node; }
@@ -292 +295 @@
 template< typename node_t >
 using readonly = ptr_base< node_t, Node::ref_type::weak >;
+
+/// Non-member swap that an participate in overload resolution.
+template< typename node_t, enum Node::ref_type ref_t >
+void swap( ptr_base< node_t, ref_t > & l, ptr_base< node_t, ref_t > & r ) {
+        l.swap( r );
+}
+
 }
 

src/AST/Pass.hpp

@@ -149 +149 @@
         const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
         const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
-        const ast::Stmt *             visit( const ast::CaseStmt             * ) override final;
+        const ast::CaseClause *       visit( const ast::CaseClause           * ) override final;
         const ast::Stmt *             visit( const ast::BranchStmt           * ) override final;
         const ast::Stmt *             visit( const ast::ReturnStmt           * ) override final;
         const ast::Stmt *             visit( const ast::ThrowStmt            * ) override final;
         const ast::Stmt *             visit( const ast::TryStmt              * ) override final;
-        const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
-        const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
+        const ast::CatchClause *      visit( const ast::CatchClause          * ) override final;
+        const ast::FinallyClause *    visit( const ast::FinallyClause        * ) override final;
         const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
@@ -184 +184 @@
         const ast::Expr *             visit( const ast::CommaExpr            * ) override final;
         const ast::Expr *             visit( const ast::TypeExpr             * ) override final;
+        const ast::Expr *             visit( const ast::DimensionExpr        * ) override final;
         const ast::Expr *             visit( const ast::AsmExpr              * ) override final;
         const ast::Expr *             visit( const ast::ImplicitCopyCtorExpr * ) override final;

src/AST/Pass.impl.hpp

@@ -354 +354 @@
                         // Take all the elements that are different in 'values'
                         // and swap them into 'container'
-                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
+                        if( values[i] != nullptr ) swap(container[i], values[i]);
                 }
 
@@ -399 +399 @@
 
         template< typename core_t >
-        template<typename node_t, typename parent_t, typename child_t>
+        template<typename node_t, typename super_t, typename field_t>
         void ast::Pass< core_t >::maybe_accept(
                 const node_t * & parent,
-                child_t parent_t::*child
+                field_t super_t::*field
         ) {
-                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
-
-                if(__pass::skip(parent->*child)) return;
-                const auto & old_val = __pass::get(parent->*child, 0);
+                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*field)) return;
+                const auto & old_val = __pass::get(parent->*field, 0);
 
                 static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
@@ -417 +417 @@
                 if( new_val.differs ) {
                         auto new_parent = __pass::mutate<core_t>(parent);
-                        new_val.apply(new_parent, child);
+                        new_val.apply(new_parent, field);
                         parent = new_parent;
                 }
@@ -423 +423 @@
 
         template< typename core_t >
-        template<typename node_t, typename parent_t, typename child_t>
+        template<typename node_t, typename super_t, typename field_t>
         void ast::Pass< core_t >::maybe_accept_as_compound(
                 const node_t * & parent,
-                child_t parent_t::*child
+                field_t super_t::*child
         ) {
-                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+                static_assert( std::is_base_of<super_t, node_t>::value, "Error deducing member object" );
 
                 if(__pass::skip(parent->*child)) return;
@@ -575 +575 @@
                         __pass::symtab::addId( core, 0, func );
                         if ( __visit_children() ) {
-                                // parameter declarations
+                                maybe_accept( node, &FunctionDecl::type_params );
+                                maybe_accept( node, &FunctionDecl::assertions );
                                 maybe_accept( node, &FunctionDecl::params );
                                 maybe_accept( node, &FunctionDecl::returns );
-                                // type params and assertions
-                                maybe_accept( node, &FunctionDecl::type_params );
-                                maybe_accept( node, &FunctionDecl::assertions );
+                                maybe_accept( node, &FunctionDecl::type );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -893 +892 @@
         if ( __visit_children() ) {
                 maybe_accept( node, &SwitchStmt::cond  );
-                maybe_accept( node, &SwitchStmt::stmts );
+                maybe_accept( node, &SwitchStmt::cases );
         }
 
@@ -900 +899 @@
 
 //--------------------------------------------------------------------------
-// CaseStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                maybe_accept( node, &CaseStmt::cond  );
-                maybe_accept( node, &CaseStmt::stmts );
-        }
-
-        VISIT_END( Stmt, node );
+// CaseClause
+template< typename core_t >
+const ast::CaseClause * ast::Pass< core_t >::visit( const ast::CaseClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &CaseClause::cond  );
+                maybe_accept( node, &CaseClause::stmts );
+        }
+
+        VISIT_END( CaseClause, node );
 }
 
@@ -964 +963 @@
 
 //--------------------------------------------------------------------------
-// CatchStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
+// CatchClause
+template< typename core_t >
+const ast::CatchClause * ast::Pass< core_t >::visit( const ast::CatchClause * node ) {
         VISIT_START( node );
 
@@ -972 +971 @@
                 // catch statements introduce a level of scope (for the caught exception)
                 guard_symtab guard { *this };
-                maybe_accept( node, &CatchStmt::decl );
-                maybe_accept( node, &CatchStmt::cond );
-                maybe_accept_as_compound( node, &CatchStmt::body );
-        }
-
-        VISIT_END( Stmt, node );
-}
-
-//--------------------------------------------------------------------------
-// FinallyStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
-        VISIT_START( node );
-
-        if ( __visit_children() ) {
-                maybe_accept( node, &FinallyStmt::body );
-        }
-
-        VISIT_END( Stmt, node );
+                maybe_accept( node, &CatchClause::decl );
+                maybe_accept( node, &CatchClause::cond );
+                maybe_accept_as_compound( node, &CatchClause::body );
+        }
+
+        VISIT_END( CatchClause, node );
+}
+
+//--------------------------------------------------------------------------
+// FinallyClause
+template< typename core_t >
+const ast::FinallyClause * ast::Pass< core_t >::visit( const ast::FinallyClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &FinallyClause::body );
+        }
+
+        VISIT_END( FinallyClause, node );
 }
 
@@ -1054 +1053 @@
                         auto n = __pass::mutate<core_t>(node);
                         for(size_t i = 0; i < new_clauses.size(); i++) {
-                                if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
+                                if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
 
                                 for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
-                                        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));
+                                        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));
                                 }
 
-                                if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
-                                if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
+                                if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
+                                if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
                         }
                         node = n;
@@ -1516 +1515 @@
                 }
                 maybe_accept( node, &TypeExpr::type );
+        }
+
+        VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// DimensionExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DimensionExpr * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                guard_symtab guard { *this };
+                maybe_accept( node, &DimensionExpr::result );
         }
 
@@ -1859 +1872 @@
 
         if ( __visit_children() ) {
-                // xxx - should PointerType visit/mutate dimension?
+                maybe_accept( node, &PointerType::dimension );
                 maybe_accept( node, &PointerType::base );
         }
@@ -2151 +2164 @@
 
         if ( __visit_children() ) {
-                {
-                        bool mutated = false;
-                        std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
-                        for ( const auto & p : node->typeEnv ) {
-                                guard_symtab guard { *this };
-                                auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
-                                new_map.insert({ p.first, new_node });
-                        }
-                        if (mutated) {
-                                auto new_node = __pass::mutate<core_t>( node );
-                                new_node->typeEnv.swap( new_map );
-                                node = new_node;
-                        }
+                bool mutated = false;
+                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
+                for ( const auto & p : node->typeEnv ) {
+                        guard_symtab guard { *this };
+                        auto new_node = p.second->accept( *this );
+                        if (new_node != p.second) mutated = true;
+                        new_map.insert({ p.first, new_node });
+                }
+                if (mutated) {
+                        auto new_node = __pass::mutate<core_t>( node );
+                        new_node->typeEnv.swap( new_map );
+                        node = new_node;
                 }
         }

src/AST/Pass.proto.hpp

@@ -26 +26 @@
 
 struct PureVisitor;
+
+template<typename node_t>
+node_t * deepCopy( const node_t * localRoot );
 
 namespace __pass {
@@ -396 +399 @@
                 static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
                         ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
-                        fwd->params = decl->params;
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
                         core.symtab.addStruct( fwd );
                 }
@@ -405 +410 @@
                 template<typename core_t>
                 static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
-                        UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
-                        fwd->params = decl->params;
+                        ast::UnionDecl * fwd = new ast::UnionDecl( decl->location, decl->name );
+                        for ( const auto & param : decl->params ) {
+                                fwd->params.push_back( deepCopy( param.get() ) );
+                        }
                         core.symtab.addUnion( fwd );
                 }

src/AST/Print.cpp

@@ -210 +210 @@
                 }
 
+                auto ptrToEnum = dynamic_cast<const ast::EnumDecl *>(node);
+                if ( ! short_mode && ptrToEnum && ptrToEnum->base ) {
+                        os << endl << indent << ".. with (enum) base" << endl;
+                        ++indent;
+                        ptrToEnum->base->accept( *this );
+                        --indent;  
+                }
+
                 os << endl;
         }
@@ -589 +597 @@
 
                 ++indent;
-                for ( const ast::Stmt * stmt : node->stmts ) {
+                for ( const ast::CaseClause * stmt : node->cases ) {
                         stmt->accept( *this );
                 }
@@ -597 +605 @@
         }
 
-        virtual const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
+        virtual const ast::CaseClause * visit( const ast::CaseClause * node ) override final {
                 if ( node->isDefault() ) {
                         os << indent << "Default ";
@@ -679 +687 @@
 
                 os << indent-1 << "... and handlers:" << endl;
-                for ( const ast::CatchStmt * stmt : node->handlers ) {
+                for ( const ast::CatchClause * stmt : node->handlers ) {
                         os << indent;
                         stmt->accept( *this );
@@ -693 +701 @@
         }
 
-        virtual const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
+        virtual const ast::CatchClause * visit( const ast::CatchClause * node ) override final {
                 os << "Catch ";
                 switch ( node->kind ) {
@@ -718 +726 @@
         }
 
-        virtual const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
+        virtual const ast::FinallyClause * visit( const ast::FinallyClause * node ) override final {
                 os << "Finally Statement" << endl;
                 os << indent << "... with block:" << endl;
@@ -1088 +1096 @@
         virtual const ast::Expr * visit( const ast::TypeExpr * node ) override final {
                 safe_print( node->type );
+                postprint( node );
+
+                return node;
+        }
+
+        virtual const ast::Expr * visit( const ast::DimensionExpr * node ) override final {
+                os << "Type-Sys Value: " << node->name;
                 postprint( node );
 

src/AST/Stmt.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 20:06:41 2022
-// Update Count     : 34
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar 28  9:50:00 2022
+// Update Count     : 35
 //
 
@@ -47 +47 @@
   private:
         Stmt * clone() const override = 0;
+        MUTATE_FRIEND
+};
+
+// Base statement component node (only serves to group them).
+class StmtClause : public ParseNode {
+  public:
+        // This is for non-statements that still belong with the statements,
+        // but are not statements, usually some sort of clause. Often these can
+        // (and should) be folded into the approprate parent node, but if they
+        // cannot be, they are sub-types of this type, for organization.
+
+    StmtClause( const CodeLocation & loc )
+                : ParseNode(loc) {}
+
+  private:
+        StmtClause * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -158 +174 @@
   public:
         ptr<Expr> cond;
+        std::vector<ptr<CaseClause>> cases;
+
+        SwitchStmt( const CodeLocation & loc, const Expr * cond,
+                                const std::vector<ptr<CaseClause>> && cases,
+                                const std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), cases(std::move(cases)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
+// Case label: case ...: or default:
+class CaseClause final : public StmtClause {
+  public:
+        // Null for the default label.
+        ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
-        SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-                                const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
-        MUTATE_FRIEND
-};
-
-// Case label: case ...: or default:
-class CaseStmt final : public Stmt {
-  public:
-        // Null for the default label.
-        ptr<Expr> cond;
-        std::vector<ptr<Stmt>> stmts;
-
-        CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
-                          const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+        CaseClause( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts )
+                : StmtClause(loc), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() const { return !cond; }
 
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
+        const CaseClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        CaseClause * clone() const override { return new CaseClause{ *this }; }
         MUTATE_FRIEND
 };
@@ -298 +314 @@
   public:
         ptr<CompoundStmt> body;
-        std::vector<ptr<CatchStmt>> handlers;
-        ptr<FinallyStmt> finally;
+        std::vector<ptr<CatchClause>> handlers;
+        ptr<FinallyClause> finally;
 
         TryStmt( const CodeLocation & loc, const CompoundStmt * body,
-                         const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
+                         const std::vector<ptr<CatchClause>> && handlers, const FinallyClause * finally,
                          const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
@@ -313 +329 @@
 
 // Catch clause of try statement
-class CatchStmt final : public Stmt {
+class CatchClause final : public StmtClause {
   public:
         ptr<Decl> decl;
@@ -320 +336 @@
         ExceptionKind kind;
 
-        CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
-                           const Stmt * body, const std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
+        CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
+                           const Stmt * body )
+                : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
+
+        const CatchClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        CatchClause * clone() const override { return new CatchClause{ *this }; }
         MUTATE_FRIEND
 };
 
 // Finally clause of try statement
-class FinallyStmt final : public Stmt {
+class FinallyClause final : public StmtClause {
   public:
         ptr<CompoundStmt> body;
 
-        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-                                 std::vector<Label> && labels = {} )
-                : Stmt(loc, std::move(labels)), body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-  private:
-        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
+        FinallyClause( const CodeLocation & loc, const CompoundStmt * body )
+                : StmtClause(loc), body(body) {}
+
+        const FinallyClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        FinallyClause * clone() const override { return new FinallyClause{ *this }; }
         MUTATE_FRIEND
 };

src/AST/TranslationUnit.hpp

@@ -10 +10 @@
 // Created On       : Tue Jun 11 15:30:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun 11 15:42:00 2019
-// Update Count     : 0
+// Last Modified On : Tue Mar 11 11:19:00 2022
+// Update Count     : 1
 //
 
@@ -23 +23 @@
 namespace ast {
 
+class TranslationGlobal {
+public:
+        std::map< UniqueId, Decl * > idMap;
+
+        ptr<Type> sizeType;
+        const FunctionDecl * dereference;
+        const StructDecl * dtorStruct;
+        const FunctionDecl * dtorDestroy;
+};
+
 class TranslationUnit {
 public:
         std::list< ptr< Decl > > decls;
-
-        struct Global {
-                std::map< UniqueId, Decl * > idMap;
-
-                ptr<Type> sizeType;
-                const FunctionDecl * dereference;
-                const StructDecl * dtorStruct;
-                const FunctionDecl * dtorDestroy;
-        } global;
+        TranslationGlobal global;
 };
 

src/AST/Type.cpp

@@ -147 +147 @@
 // --- TypeInstType
 
+TypeInstType::TypeInstType( const TypeDecl * b,
+        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
+: BaseInstType( b->name, q, move(as) ), base( b ), kind( b->kind ) {}
+
 void TypeInstType::set_base( const TypeDecl * b ) {
         base = b;

src/AST/Type.hpp

@@ -421 +421 @@
                 std::vector<ptr<Attribute>> && as = {} )
         : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
+
+        TypeInstType( const TypeDecl * b,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )

src/AST/TypeSubstitution.hpp

@@ -37 +37 @@
   public:
         TypeSubstitution();
+        template< typename FormalContainer, typename ActualContainer >
+        TypeSubstitution( FormalContainer formals, ActualContainer actuals );
         template< typename FormalIterator, typename ActualIterator >
         TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
@@ -76 +78 @@
         bool empty() const;
 
+        template< typename FormalContainer, typename ActualContainer >
+        void addAll( FormalContainer formals, ActualContainer actuals );
         template< typename FormalIterator, typename ActualIterator >
-        void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+        void addAll( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
 
         /// create a new TypeSubstitution using bindings from env containing all of the type variables in expr
@@ -112 +116 @@
 };
 
+template< typename FormalContainer, typename ActualContainer >
+TypeSubstitution::TypeSubstitution( FormalContainer formals, ActualContainer actuals ) {
+        assert( formals.size() == actuals.size() );
+        addAll( formals.begin(), formals.end(), actuals.begin() );
+}
+
+template< typename FormalIterator, typename ActualIterator >
+TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
+        addAll( formalBegin, formalEnd, actualBegin );
+}
+
+template< typename FormalContainer, typename ActualContainer >
+void TypeSubstitution::addAll( FormalContainer formals, ActualContainer actuals ) {
+        assert( formals.size() == actuals.size() );
+        addAll( formals.begin(), formals.end(), actuals.begin() );
+}
+
 // this is the only place where type parameters outside a function formal may be substituted.
 template< typename FormalIterator, typename ActualIterator >
-void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
+void TypeSubstitution::addAll( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
         // FormalIterator points to a TypeDecl
         // ActualIterator points to a Type
@@ -129 +150 @@
                         } // if
                 } else {
-                        
+                        // Is this an error?
                 } // if
         } // for
 }
-
-
-
-template< typename FormalIterator, typename ActualIterator >
-TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
-        add( formalBegin, formalEnd, actualBegin );
-}
-
 
 } // namespace ast

src/AST/Util.cpp

@@ -10 +10 @@
 // Created On       : Wed Jan 19  9:46:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Feb 18  9:42:00 2022
-// Update Count     : 0
+// Last Modified On : Fri Mar 11 18:07:00 2022
+// Update Count     : 1
 //
 
 #include "Util.hpp"
 
-#include "Decl.hpp"
 #include "Node.hpp"
+#include "ParseNode.hpp"
 #include "Pass.hpp"
 #include "TranslationUnit.hpp"
-#include "Common/ScopedMap.h"
 
 #include <vector>
@@ -46 +45 @@
 };
 
+/// Check that every note that can has a set CodeLocation.
+struct SetCodeLocationsCore {
+        void previsit( const ParseNode * node ) {
+                assert( node->location.isSet() );
+        }
+};
+
 struct InvariantCore {
         // To save on the number of visits: this is a kind of composed core.
         // 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 );
+        }
+
+        void previsit( const ParseNode * node ) {
+                no_strong_cycles.previsit( node );
+                set_code_locations.previsit( node );
         }
 

src/AST/Visitor.hpp

@@ -41 +41 @@
     virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::CaseStmt             * ) = 0;
+    virtual const ast::CaseClause *       visit( const ast::CaseClause           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::BranchStmt           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ReturnStmt           * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ThrowStmt            * ) = 0;
     virtual const ast::Stmt *             visit( const ast::TryStmt              * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
+    virtual const ast::CatchClause *      visit( const ast::CatchClause          * ) = 0;
+    virtual const ast::FinallyClause *    visit( const ast::FinallyClause        * ) = 0;
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
@@ -76 +76 @@
     virtual const ast::Expr *             visit( const ast::CommaExpr            * ) = 0;
     virtual const ast::Expr *             visit( const ast::TypeExpr             * ) = 0;
+    virtual const ast::Expr *             visit( const ast::DimensionExpr        * ) = 0;
     virtual const ast::Expr *             visit( const ast::AsmExpr              * ) = 0;
     virtual const ast::Expr *             visit( const ast::ImplicitCopyCtorExpr * ) = 0;