Changeset 24ceace for src

Timestamp:

May 2, 2022, 3:19:03 AM (4 years ago)

Author:

JiadaL <j82liang@…>

Branches:

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

Children:

12bb5ab1, 49a1684

Parents:

9e7236f4 (diff), 4b4f95f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Location:

src

Files:

• AST/Convert.cpp (modified) (4 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Stmt.hpp (modified) (3 diffs)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Common/utility.h (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (6 diffs)
• SymTab/Validate.cc (modified) (3 diffs)
• SymTab/Validate.h (modified) (1 diff)
• Validate/EliminateTypedef.cpp (added)
• Validate/EliminateTypedef.hpp (added)
• Validate/FixQualifiedTypes.cpp (added)
• Validate/FixQualifiedTypes.hpp (added)
• Validate/ForallPointerDecay.cpp (modified) (2 diffs)
• Validate/ForallPointerDecay.hpp (modified) (2 diffs)
• Validate/GenericParameter.cpp (modified) (3 diffs)
• Validate/HoistStruct.cpp (added)
• Validate/HoistStruct.hpp (added)
• Validate/NoIdSymbolTable.hpp (added)
• Validate/module.mk (modified) (2 diffs)
• main.cc (modified) (5 diffs)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Mar 16 15:01:00 2022
-// Update Count     : 42
+// Last Modified On : Wed Apr 20 13:58:00 2022
+// Update Count     : 43
 //
 
@@ -562 +562 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause.target.func ),
-                                        get<Expression>().acceptL( clause.target.args ),
+                                        get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().acceptL( clause->target_args ),
                                 },
-                                get<Statement>().accept1( clause.stmt ),
-                                get<Expression>().accept1( clause.cond ),
+                                get<Statement>().accept1( clause->stmt ),
+                                get<Expression>().accept1( clause->cond ),
                         });
                 }
                 stmt->timeout = {
-                        get<Expression>().accept1( node->timeout.time ),
-                        get<Statement>().accept1( node->timeout.stmt ),
-                        get<Expression>().accept1( node->timeout.cond ),
+                        get<Expression>().accept1( node->timeout_time ),
+                        get<Statement>().accept1( node->timeout_stmt ),
+                        get<Expression>().accept1( node->timeout_cond ),
                 };
                 stmt->orelse = {
-                        get<Statement>().accept1( node->orElse.stmt ),
-                        get<Expression>().accept1( node->orElse.cond ),
+                        get<Statement>().accept1( node->else_stmt ),
+                        get<Expression>().accept1( node->else_cond ),
                 };
                 return stmtPostamble( stmt, node );
+        }
+
+        const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
+                // There is no old-AST WaitForClause, so this should never be called.
+                assert( !node );
+                return nullptr;
         }
 
@@ -2096 +2102 @@
                 stmt->clauses.reserve( old->clauses.size() );
                 for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
-                        stmt->clauses.push_back({
-                                ast::WaitForStmt::Target{
-                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
-                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
-                                },
-                                GET_ACCEPT_1(clauses[i].statement, Stmt),
-                                GET_ACCEPT_1(clauses[i].condition, Expr)
-                        });
-                }
-                stmt->timeout = {
-                        GET_ACCEPT_1(timeout.time, Expr),
-                        GET_ACCEPT_1(timeout.statement, Stmt),
-                        GET_ACCEPT_1(timeout.condition, Expr),
-                };
-                stmt->orElse = {
-                        GET_ACCEPT_1(orelse.statement, Stmt),
-                        GET_ACCEPT_1(orelse.condition, Expr),
-                };
+                        auto clause = new ast::WaitForClause( old->location );
+
+                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
+                        clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
+                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+
+                        stmt->clauses.push_back( clause );
+                }
+                stmt->timeout_time = GET_ACCEPT_1(timeout.time, Expr);
+                stmt->timeout_stmt = GET_ACCEPT_1(timeout.statement, Stmt);
+                stmt->timeout_cond = GET_ACCEPT_1(timeout.condition, Expr);
+                stmt->else_stmt = GET_ACCEPT_1(orelse.statement, Stmt);
+                stmt->else_cond = GET_ACCEPT_1(orelse.condition, Expr);
 
                 this->node = stmt;
@@ -2727 +2729 @@
                         ty->forall.emplace_back(new ast::TypeInstType(param));
                         for (auto asst : param->assertions) {
-                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
+                                ty->assertions.emplace_back(
+                                        new ast::VariableExpr(param->location, asst));
                         }
                 }

src/AST/Fwd.hpp

@@ -56 +56 @@
 class SuspendStmt;
 class WaitForStmt;
+class WaitForClause;
 class WithStmt;
 class DeclStmt;

src/AST/Node.cpp

@@ -176 +176 @@
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WaitForStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::WaitForClause, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::WithStmt, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -158 +158 @@
         const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
+        const ast::WaitForClause *    visit( const ast::WaitForClause        * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
         const ast::NullStmt *         visit( const ast::NullStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -1010 +1010 @@
 const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
         VISIT_START( node );
-                // for( auto & clause : node->clauses ) {
-                //      maybeAccept_impl( clause.target.function, *this );
-                //      maybeAccept_impl( clause.target.arguments, *this );
-
-                //      maybeAccept_impl( clause.statement, *this );
-                //      maybeAccept_impl( clause.condition, *this );
-                // }
-
-        if ( __visit_children() ) {
-                std::vector<WaitForStmt::Clause> new_clauses;
-                new_clauses.reserve( node->clauses.size() );
-                bool mutated = false;
-                for( const auto & clause : node->clauses ) {
-
-                        const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
-                        if(func != clause.target.func) mutated = true;
-                        else func = nullptr;
-
-                        std::vector<ptr<Expr>> new_args;
-                        new_args.reserve(clause.target.args.size());
-                        for( const auto & arg : clause.target.args ) {
-                                auto a = arg->accept(*this);
-                                if( a != arg ) {
-                                        mutated = true;
-                                        new_args.push_back( a );
-                                } else
-                                        new_args.push_back( nullptr );
-                        }
-
-                        const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
-                        if(stmt != clause.stmt) mutated = true;
-                        else stmt = nullptr;
-
-                        const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
-                        if(cond != clause.cond) mutated = true;
-                        else cond = nullptr;
-
-                        new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
-                }
-
-                if(mutated) {
-                        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) 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) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
-                                }
-
-                                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;
-                }
-        }
-
-        #define maybe_accept(field) \
-                if(node->field) { \
-                        auto nval = call_accept( node->field ); \
-                        if(nval.differs ) { \
-                                auto nparent = __pass::mutate<core_t>(node); \
-                                nparent->field = nval.value; \
-                                node = nparent; \
-                        } \
-                }
-
-        if ( __visit_children() ) {
-                maybe_accept( timeout.time );
-                maybe_accept( timeout.stmt );
-                maybe_accept( timeout.cond );
-                maybe_accept( orElse.stmt  );
-                maybe_accept( orElse.cond  );
-        }
-
-        #undef maybe_accept
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WaitForStmt::clauses );
+                maybe_accept( node, &WaitForStmt::timeout_time );
+                maybe_accept( node, &WaitForStmt::timeout_stmt );
+                maybe_accept( node, &WaitForStmt::timeout_cond );
+                maybe_accept( node, &WaitForStmt::else_stmt );
+                maybe_accept( node, &WaitForStmt::else_cond );
+        }
 
         VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
+// WaitForClause
+template< typename core_t >
+const ast::WaitForClause * ast::Pass< core_t >::visit( const ast::WaitForClause * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                maybe_accept( node, &WaitForClause::target_func );
+                maybe_accept( node, &WaitForClause::target_args );
+                maybe_accept( node, &WaitForClause::stmt );
+                maybe_accept( node, &WaitForClause::cond );
+        }
+
+        VISIT_END( WaitForClause, node );
 }
 

src/AST/Print.cpp

@@ -760 +760 @@
                 indent += 2;
                 for( const auto & clause : node->clauses ) {
-                        os << indent-1 << "target function: ";
-                        safe_print( clause.target.func );
-
-                        if ( ! clause.target.args.empty() ) {
-                                os << endl << indent-1 << "... with arguments:" << endl;
-                                for( const ast::Expr * arg : clause.target.args ) {
-                                        arg->accept( *this );
-                                }
+                        clause->accept( *this );
+                }
+
+                if ( node->timeout_time ) {
+                        os << indent-1 << "timeout of:" << endl;
+                        node->timeout_time->accept( *this );
+
+                        if ( node->timeout_stmt ) {
+                                os << indent-1 << "... with statment:" << endl;
+                                node->timeout_stmt->accept( *this );
                         }
 
-                        if ( clause.stmt ) {
-                                os << indent-1 << "... with statment:" << endl;
-                                clause.stmt->accept( *this );
+                        if ( node->timeout_cond ) {
+                                os << indent-1 << "... with condition:" << endl;
+                                node->timeout_cond->accept( *this );
                         }
-
-                        if ( clause.cond ) {
+                }
+
+                if ( node->else_stmt ) {
+                        os << indent-1 << "else:" << endl;
+                        node->else_stmt->accept( *this );
+
+                        if ( node->else_cond ) {
                                 os << indent-1 << "... with condition:" << endl;
-                                clause.cond->accept( *this );
+                                node->else_cond->accept( *this );
                         }
                 }
 
-                if ( node->timeout.time ) {
-                        os << indent-1 << "timeout of:" << endl;
-                        node->timeout.time->accept( *this );
-
-                        if ( node->timeout.stmt ) {
-                                os << indent-1 << "... with statment:" << endl;
-                                node->timeout.stmt->accept( *this );
+                return node;
+        }
+
+        virtual const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
+                os << indent-1 << "target function: ";
+                safe_print( node->target_func );
+
+                if ( !node->target_args.empty() ) {
+                        os << endl << indent-1 << "... with arguments:" << endl;
+                        for( const ast::Expr * arg : node->target_args ) {
+                                arg->accept( *this );
                         }
-
-                        if ( node->timeout.cond ) {
-                                os << indent-1 << "... with condition:" << endl;
-                                node->timeout.cond->accept( *this );
-                        }
-                }
-
-                if ( node->orElse.stmt ) {
-                        os << indent-1 << "else:" << endl;
-                        node->orElse.stmt->accept( *this );
-
-                        if ( node->orElse.cond ) {
-                                os << indent-1 << "... with condition:" << endl;
-                                node->orElse.cond->accept( *this );
-                        }
-                }
-                indent -= 2;
+                }
+
+                if ( node->stmt ) {
+                        os << indent-1 << "... with statment:" << endl;
+                        node->stmt->accept( *this );
+                }
+
+                if ( node->cond ) {
+                        os << indent-1 << "... with condition:" << endl;
+                        node->cond->accept( *this );
+                }
 
                 return node;

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Mar 28  9:50:00 2022
-// Update Count     : 35
+// Last Modified On : Wed Apr 20 14:34:00 2022
+// Update Count     : 36
 //
 
@@ -378 +378 @@
 class WaitForStmt final : public Stmt {
   public:
-        struct Target {
-                ptr<Expr> func;
-                std::vector<ptr<Expr>> args;
-        };
-
-        struct Clause {
-                Target target;
-                ptr<Stmt> stmt;
-                ptr<Expr> cond;
-        };
-
-        struct Timeout {
-                ptr<Expr> time;
-                ptr<Stmt> stmt;
-                ptr<Expr> cond;
-        };
-
-        struct OrElse {
-                ptr<Stmt> stmt;
-                ptr<Expr> cond;
-        };
-
-        std::vector<Clause> clauses;
-        Timeout timeout;
-        OrElse orElse;
+        std::vector<ptr<WaitForClause>> clauses;
+        ptr<Expr> timeout_time;
+        ptr<Stmt> timeout_stmt;
+        ptr<Expr> timeout_cond;
+        ptr<Stmt> else_stmt;
+        ptr<Expr> else_cond;
 
         WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
@@ -411 +392 @@
         WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
         MUTATE_FRIEND
+};
+
+class WaitForClause final : public StmtClause {
+  public:
+    ptr<Expr> target_func;
+    std::vector<ptr<Expr>> target_args;
+    ptr<Stmt> stmt;
+    ptr<Expr> cond;
+
+    WaitForClause( const CodeLocation & loc )
+                : StmtClause( loc ) {}
+
+        const WaitForClause * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+    WaitForClause * clone() const override { return new WaitForClause{ *this }; }
+    MUTATE_FRIEND
 };
 

src/AST/Visitor.hpp

@@ -50 +50 @@
     virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
+    virtual const ast::WaitForClause *    visit( const ast::WaitForClause        * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;
     virtual const ast::NullStmt *         visit( const ast::NullStmt             * ) = 0;

src/Common/CodeLocationTools.cpp

@@ -121 +121 @@
     macro(SuspendStmt, Stmt) \
     macro(WaitForStmt, Stmt) \
+    macro(WaitForClause, WaitForClause) \
     macro(WithStmt, Decl) \
     macro(NullStmt, NullStmt) \

src/Common/utility.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 11 13:00:36 2020
-// Update Count     : 50
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Apr 25 14:26:00 2022
+// Update Count     : 51
 //
 
@@ -230 +230 @@
 }
 
+template<typename Container, typename Pred>
+void erase_if( Container & cont, Pred && pred ) {
+        auto keep_end = std::remove_if( cont.begin(), cont.end(), pred );
+        cont.erase( keep_end, cont.end() );
+}
+
 template< typename... Args >
 auto zip(Args&&... args) -> decltype(zipWith(std::forward<Args>(args)..., std::make_pair)) {

src/ResolvExpr/Resolver.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 18 10:41:00 2022
-// Update Count     : 247
+// Last Modified On : Wed Apr 20 10:41:00 2022
+// Update Count     : 248
 //
 
@@ -1722 +1722 @@
                 // Resolve all clauses first
                 for ( unsigned i = 0; i < stmt->clauses.size(); ++i ) {
-                        const ast::WaitForStmt::Clause & clause = stmt->clauses[i];
+                        const ast::WaitForClause & clause = *stmt->clauses[i];
 
                         ast::TypeEnvironment env;
@@ -1728 +1728 @@
 
                         // Find all candidates for a function in canonical form
-                        funcFinder.find( clause.target.func, ResolvMode::withAdjustment() );
+                        funcFinder.find( clause.target_func, ResolvMode::withAdjustment() );
 
                         if ( funcFinder.candidates.empty() ) {
                                 stringstream ss;
                                 ss << "Use of undeclared indentifier '";
-                                ss << clause.target.func.strict_as< ast::NameExpr >()->name;
+                                ss << clause.target_func.strict_as< ast::NameExpr >()->name;
                                 ss << "' in call to waitfor";
                                 SemanticError( stmt->location, ss.str() );
                         }
 
-                        if ( clause.target.args.empty() ) {
+                        if ( clause.target_args.empty() ) {
                                 SemanticError( stmt->location,
                                         "Waitfor clause must have at least one mutex parameter");
@@ -1745 +1745 @@
                         // Find all alternatives for all arguments in canonical form
                         std::vector< CandidateFinder > argFinders =
-                                funcFinder.findSubExprs( clause.target.args );
+                                funcFinder.findSubExprs( clause.target_args );
 
                         // List all combinations of arguments
@@ -1918 +1918 @@
 
                         // build new clause
-                        ast::WaitForStmt::Clause clause2;
-
-                        clause2.target.func = funcCandidates.front()->expr;
-
-                        clause2.target.args.reserve( clause.target.args.size() );
+                        auto clause2 = new ast::WaitForClause( clause.location );
+
+                        clause2->target_func = funcCandidates.front()->expr;
+
+                        clause2->target_args.reserve( clause.target_args.size() );
                         const ast::StructDecl * decl_monitor = symtab.lookupStruct( "monitor$" );
                         for ( auto arg : argsCandidates.front() ) {
@@ -1939 +1939 @@
                                 );
 
-                                clause2.target.args.emplace_back( findSingleExpression( init, context ) );
+                                clause2->target_args.emplace_back( findSingleExpression( init, context ) );
                         }
 
                         // Resolve the conditions as if it were an IfStmt, statements normally
-                        clause2.cond = findSingleExpression( clause.cond, context );
-                        clause2.stmt = clause.stmt->accept( *visitor );
+                        clause2->cond = findSingleExpression( clause.cond, context );
+                        clause2->stmt = clause.stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->clauses[i] = std::move( clause2 );
+                        n->clauses[i] = clause2;
                         stmt = n;
                 }
 
-                if ( stmt->timeout.stmt ) {
+                if ( stmt->timeout_stmt ) {
                         // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
-                        ast::WaitForStmt::Timeout timeout2;
-
                         ast::ptr< ast::Type > target =
                                 new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
-                        timeout2.time = findSingleExpression( stmt->timeout.time, target, context );
-                        timeout2.cond = findSingleExpression( stmt->timeout.cond, context );
-                        timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
+                        auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
+                        auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
+                        auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->timeout = std::move( timeout2 );
+                        n->timeout_time = std::move( timeout_time );
+                        n->timeout_cond = std::move( timeout_cond );
+                        n->timeout_stmt = std::move( timeout_stmt );
                         stmt = n;
                 }
 
-                if ( stmt->orElse.stmt ) {
+                if ( stmt->else_stmt ) {
                         // resolve the condition like IfStmt, stmts normally
-                        ast::WaitForStmt::OrElse orElse2;
-
-                        orElse2.cond = findSingleExpression( stmt->orElse.cond, context );
-                        orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
+                        auto else_cond = findSingleExpression( stmt->else_cond, context );
+                        auto else_stmt = stmt->else_stmt->accept( *visitor );
 
                         // set results into stmt
                         auto n = mutate( stmt );
-                        n->orElse = std::move( orElse2 );
+                        n->else_cond = std::move( else_cond );
+                        n->else_stmt = std::move( else_stmt );
                         stmt = n;
                 }

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 12 11:00:00 2021
-// Update Count     : 364
+// Last Modified On : Fri Apr 29  9:45:00 2022
+// Update Count     : 365
 //
 
@@ -143 +143 @@
         struct LinkReferenceToTypes_old final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes_old>, public WithShortCircuiting {
                 LinkReferenceToTypes_old( const Indexer * indexer );
+
                 void postvisit( TypeInstType * typeInst );
 
@@ -370 +371 @@
         }
 
+        void linkReferenceToTypes( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
+                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+        }
+
         void validate_B( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
                 PassVisitor<FixQualifiedTypes> fixQual;
                 {
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
-                        acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        //linkReferenceToTypes( translationUnit );
                         mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         HoistStruct::hoistStruct( translationUnit );

src/SymTab/Validate.h

@@ -42 +42 @@
         void validate_E( std::list< Declaration * > &translationUnit );
         void validate_F( std::list< Declaration * > &translationUnit );
+        void linkReferenceToTypes( std::list< Declaration * > &translationUnit );
 
         const ast::Type * validateType(

src/Validate/ForallPointerDecay.cpp

@@ -10 +10 @@
 // Created On       : Tue Dec  7 16:15:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Feb 11 10:59:00 2022
-// Update Count     : 0
+// Last Modified On : Sat Apr 23 13:10:00 2022
+// Update Count     : 1
 //
 
@@ -237 +237 @@
 }
 
+std::vector<ast::ptr<ast::DeclWithType>> expandAssertions(
+                std::vector<ast::ptr<ast::DeclWithType>> const & old ) {
+        return TraitExpander::expandAssertions( old );
+}
+
 } // namespace Validate
 

src/Validate/ForallPointerDecay.hpp

@@ -10 +10 @@
 // Created On       : Tue Dec  7 16:15:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Dec  8 11:50:00 2021
-// Update Count     : 0
+// Last Modified On : Sat Apr 23 13:13:00 2022
+// Update Count     : 1
 //
 
 #pragma once
 
+#include <vector>
+#include "AST/Node.hpp"
+
 namespace ast {
+        class DeclWithType;
         class TranslationUnit;
 }
@@ -27 +31 @@
 void decayForallPointers( ast::TranslationUnit & transUnit );
 
+/// Expand all traits in an assertion list.
+std::vector<ast::ptr<ast::DeclWithType>> expandAssertions(
+        std::vector<ast::ptr<ast::DeclWithType>> const & );
+
 }
 

src/Validate/GenericParameter.cpp

@@ -10 +10 @@
 // Created On       : Fri Mar 21 10:02:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 13 10:09:00 2022
-// Update Count     : 0
+// Last Modified On : Fri Apr 22 16:43:00 2022
+// Update Count     : 1
 //
 
@@ -22 +22 @@
 #include "AST/TranslationUnit.hpp"
 #include "AST/Type.hpp"
+#include "Validate/NoIdSymbolTable.hpp"
 
 namespace Validate {
@@ -138 +139 @@
 // --------------------------------------------------------------------------
 
-// A SymbolTable that only has the operations used in the Translate Dimension
-// pass. More importantly, it doesn't have some methods that should no be
-// called by the Pass template (lookupId and addId).
-class NoIdSymbolTable {
-        ast::SymbolTable base;
-public:
-#       define FORWARD_X( func, types_and_names, just_names ) \
-        inline auto func types_and_names -> decltype( base.func just_names ) { \
-                return base.func just_names ; \
-        }
-#       define FORWARD_0( func )         FORWARD_X( func, (),             () )
-#       define FORWARD_1( func, type )   FORWARD_X( func, (type arg),     (arg) )
-#       define FORWARD_2( func, t0, t1 ) FORWARD_X( func, (t0 a0, t1 a1), (a0, a1) )
-
-        FORWARD_0( enterScope )
-        FORWARD_0( leaveScope )
-        FORWARD_1( lookupType, const std::string &        )
-        FORWARD_1( addType   , const ast::NamedTypeDecl * )
-        FORWARD_1( addStruct , const ast::StructDecl *    )
-        FORWARD_1( addEnum   , const ast::EnumDecl *      )
-        FORWARD_1( addUnion  , const ast::UnionDecl *     )
-        FORWARD_1( addTrait  , const ast::TraitDecl *     )
-        FORWARD_2( addWith   , const std::vector< ast::ptr<ast::Expr> > &, const ast::Decl * )
-};
-
-struct TranslateDimensionCore : public ast::WithGuards {
-        NoIdSymbolTable symtab;
+struct TranslateDimensionCore :
+                public WithNoIdSymbolTable, public ast::WithGuards {
 
         // SUIT: Struct- or Union- InstType

src/Validate/module.mk

@@ -20 +20 @@
         Validate/CompoundLiteral.cpp \
         Validate/CompoundLiteral.hpp \
+        Validate/EliminateTypedef.cpp \
+        Validate/EliminateTypedef.hpp \
+        Validate/FixQualifiedTypes.cpp \
+        Validate/FixQualifiedTypes.hpp \
         Validate/ForallPointerDecay.cpp \
         Validate/ForallPointerDecay.hpp \
@@ -26 +30 @@
         Validate/HandleAttributes.cc \
         Validate/HandleAttributes.h \
+        Validate/HoistStruct.cpp \
+        Validate/HoistStruct.hpp \
         Validate/InitializerLength.cpp \
         Validate/InitializerLength.hpp \
         Validate/LabelAddressFixer.cpp \
         Validate/LabelAddressFixer.hpp \
+        Validate/NoIdSymbolTable.hpp \
         Validate/ReturnCheck.cpp \
         Validate/ReturnCheck.hpp \

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 13 11:11:00 2022
-// Update Count     : 672
+// Last Modified On : Fri Apr 29  9:52:00 2022
+// Update Count     : 673
 //
 
@@ -75 +75 @@
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
 #include "Validate/Autogen.hpp"             // for autogenerateRoutines
+#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
+#include "Validate/EliminateTypedef.hpp"    // for eliminateTypedef
+#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
+#include "Validate/FixQualifiedTypes.hpp"   // for fixQualifiedTypes
+#include "Validate/ForallPointerDecay.hpp"  // for decayForallPointers
 #include "Validate/GenericParameter.hpp"    // for fillGenericParameters, tr...
-#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
-#include "Validate/ForallPointerDecay.hpp"  // for decayForallPointers
-#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
+#include "Validate/HoistStruct.hpp"         // for hoistStruct
 #include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
@@ -328 +331 @@
                 // add the assignment statement after the initialization of a type parameter
                 PASS( "Validate-A", SymTab::validate_A( translationUnit ) );
-                PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
+
+                // Must happen before auto-gen, because it uses the sized flag.
+                PASS( "Link Reference To Types", SymTab::linkReferenceToTypes( translationUnit ) );
 
                 CodeTools::fillLocations( translationUnit );
@@ -342 +347 @@
 
                         forceFillCodeLocations( transUnit );
+
+                        // Must happen after Link References To Types,
+                        // because aggregate members are accessed.
+                        PASS( "Fix Qualified Types", Validate::fixQualifiedTypes( transUnit ) );
+
+                        PASS( "Hoist Struct", Validate::hoistStruct( transUnit ) );
+                        PASS( "Eliminate Typedef", Validate::eliminateTypedef( transUnit ) );
 
                         // Check as early as possible. Can't happen before
@@ -438 +450 @@
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
                         PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
                         PASS( "Validate-D", SymTab::validate_D( translationUnit ) );