Changeset c76bd34 for src

Timestamp:

Oct 7, 2020, 4:31:43 PM (5 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

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

Children:

848439f

Parents:

ae2c27a (diff), 597c5d18 (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 into master

Location:

src

Files:

• AST/Convert.cpp (modified) (7 diffs)
• AST/Decl.hpp (modified) (1 diff)
• AST/ForallSubstitutor.hpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/GenericSubstitution.cpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (6 diffs)
• AST/Pass.impl.hpp (modified) (4 diffs)
• AST/Pass.proto.hpp (modified) (2 diffs)
• AST/Print.cpp (modified) (1 diff)
• AST/SymbolTable.cpp (modified) (5 diffs)
• AST/SymbolTable.hpp (modified) (1 diff)
• AST/Type.cpp (modified) (6 diffs)
• AST/Type.hpp (modified) (10 diffs)
• AST/TypeSubstitution.cpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (1 diff)
• Common/Examine.cc (added)
• Common/Examine.h (added)
• Common/Stats/ResolveTime.cc (added)
• Common/Stats/ResolveTime.h (added)
• Common/Stats/Stats.cc (modified) (2 diffs)
• Common/module.mk (modified) (2 diffs)
• Concurrency/Keywords.cc (modified) (17 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/lex.ll (modified) (3 diffs)
• Parser/parser.yy (modified) (9 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.h (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (modified) (5 diffs)
• ResolvExpr/Resolver.cc (modified) (9 diffs)
• ResolvExpr/SatisfyAssertions.cpp (modified) (1 diff)
• ResolvExpr/SpecCost.cc (modified) (1 diff)
• ResolvExpr/Unify.cc (modified) (12 diffs)
• SymTab/Mangler.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (6 diffs)
• Virtual/Tables.cc (added)
• Virtual/Tables.h (added)
• Virtual/module.mk (modified) (1 diff)

src/AST/Convert.cpp

@@ -177 +177 @@
         const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
                 if ( inCache( node ) ) return nullptr;
+
+                // function decl contains real variables that the type must use.
+                // the structural change means function type in and out of decl
+                // must be handled **differently** on convert back to old.
+                auto ftype = new FunctionType(
+                        cv(node->type),
+                        (bool)node->type->isVarArgs
+                );
+                ftype->returnVals = get<DeclarationWithType>().acceptL(node->returns);
+                ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
+
+                visitType(node->type, ftype);
+
                 auto decl = new FunctionDecl(
                         node->name,
                         Type::StorageClasses( node->storage.val ),
                         LinkageSpec::Spec( node->linkage.val ),
-                        get<FunctionType>().accept1( node->type ),
+                        ftype,
+                        //get<FunctionType>().accept1( node->type ),
                         {},
                         get<Attribute>().acceptL( node->attributes ),
@@ -1152 +1168 @@
 
         const ast::Type * visit( const ast::FunctionType * node ) override final {
+                static std::string dummy_paramvar_prefix = "__param_";
+                static std::string dummy_returnvar_prefix = "__retval_";
+
                 auto ty = new FunctionType {
                         cv( node ),
                         (bool)node->isVarArgs
                 };
-                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
-                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
+                auto returns = get<Type>().acceptL(node->returns);
+                auto params = get<Type>().acceptL(node->params);
+
+                int ret_index = 0;
+                for (auto t: returns) {
+                        // xxx - LinkageSpec shouldn't matter but needs to be something
+                        ObjectDecl * dummy = new ObjectDecl(dummy_returnvar_prefix + std::to_string(ret_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->returnVals.push_back(dummy);
+                }
+                int param_index = 0;
+                for (auto t: params) {
+                        ObjectDecl * dummy = new ObjectDecl(dummy_paramvar_prefix + std::to_string(param_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->parameters.push_back(dummy);
+                }
+
+                // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
         }
 
-        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
+        const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
                 ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
@@ -1374 +1408 @@
         ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
-        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
+        /// in case that some nodes are dropped by conversion (due to possible structural change)
+        /// use smart pointers in cache value to prevent accidental invalidation.
+        /// at conversion stage, all created nodes are guaranteed to be unique, therefore
+        /// const_casting out of smart pointers is permitted.
+        std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
 
         // Local Utilities:
@@ -1447 +1485 @@
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
-                node = it->second;
+                node = const_cast<ast::Node *>(it->second.get());
                 return true;
         }
@@ -1486 +1524 @@
         virtual void visit( const FunctionDecl * old ) override final {
                 if ( inCache( old ) ) return;
+                auto paramVars = GET_ACCEPT_V(type->parameters, DeclWithType);
+                auto returnVars = GET_ACCEPT_V(type->returnVals, DeclWithType);
+                auto forall = GET_ACCEPT_V(type->forall, TypeDecl);
+
+                // function type is now derived from parameter decls instead of storing them
+                auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
+                ftype->params.reserve(paramVars.size());
+                ftype->returns.reserve(returnVars.size());
+
+                for (auto & v: paramVars) {
+                        ftype->params.emplace_back(v->get_type());
+                }
+                for (auto & v: returnVars) {
+                        ftype->returns.emplace_back(v->get_type());
+                }
+                ftype->forall = std::move(forall);
+                visitType(old->type, ftype);
+
                 auto decl = new ast::FunctionDecl{
                         old->location,
                         old->name,
-                        GET_ACCEPT_1(type, FunctionType),
+                        // GET_ACCEPT_1(type, FunctionType),
+                        std::move(paramVars),
+                        std::move(returnVars),
                         {},
                         { old->storageClasses.val },
@@ -1496 +1554 @@
                         { old->get_funcSpec().val }
                 };
+
+                decl->type = ftype;
                 cache.emplace( old, decl );
+
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -2515 +2576 @@
                         cv( old )
                 };
-                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
-                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                auto returnVars = GET_ACCEPT_V(returnVals, DeclWithType);
+                auto paramVars = GET_ACCEPT_V(parameters, DeclWithType);
+                // ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                // ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                for (auto & v: returnVars) {
+                        ty->returns.emplace_back(v->get_type());
+                }
+                for (auto & v: paramVars) {
+                        ty->params.emplace_back(v->get_type());
+                }
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );
         }
 
-        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
+        void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 ty->params = GET_ACCEPT_V( parameters, Expr );

src/AST/Decl.hpp

@@ -124 +124 @@
 class FunctionDecl : public DeclWithType {
 public:
+        std::vector<ptr<DeclWithType>> params;
+        std::vector<ptr<DeclWithType>> returns;
+        // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
+        FunctionDecl( const CodeLocation & loc, const std::string & name, 
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
           stmts( stmts ) {}
 

src/AST/ForallSubstitutor.hpp

@@ -33 +33 @@
         }
 
+        template<typename node_t > 
+        std::vector<ptr<node_t>> operator() (const std::vector<ptr<node_t>> & o) {
+                std::vector<ptr<node_t>> n;
+                n.reserve(o.size());
+                for (const node_t * d : o) { n.emplace_back(d->accept(*visitor)); }
+                return n;
+        }
+        
+        /*
+
         /// Substitute parameter/return type
         std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) {
@@ -48 +58 @@
                 return n;
         }
+
+        */
 };
 

src/AST/Fwd.hpp

@@ -107 +107 @@
 class QualifiedType;
 class FunctionType;
-class ReferenceToType;
+class BaseInstType;
 template<typename decl_t> class SueInstType;
 using StructInstType = SueInstType<StructDecl>;

src/AST/GenericSubstitution.cpp

@@ -42 +42 @@
         private:
                 // make substitution for generic type
-                void makeSub( const ReferenceToType * ty ) {
+                void makeSub( const BaseInstType * ty ) {
                         visit_children = false;
                         const AggregateDecl * aggr = ty->aggr();

src/AST/Node.cpp

@@ -266 +266 @@
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -50 +50 @@
 // | PureVisitor           - makes the visitor pure, it never modifies nodes in place and always
 //                           clones nodes it needs to make changes to
-// | WithTypeSubstitution  - provides polymorphic const TypeSubstitution * env for the
+// | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs for the
 //                           current expression
 // | WithStmtsToAdd        - provides the ability to insert statements before or after the current
@@ -67 +67 @@
 // | WithSymbolTable       - provides symbol table functionality
 // | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
+//
+// Other Special Members:
+// | result                - Either a method that takes no parameters or a field. If a method (or
+//                           callable field) get_result calls it, otherwise the value is returned.
 //-------------------------------------------------------------------------------------------------
 template< typename core_t >
@@ -89 +93 @@
         virtual ~Pass() = default;
 
+        /// Storage for the actual pass.
+        core_t core;
+
+        /// If the core defines a result, call it if possible, otherwise return it.
+        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
+                return __pass::get_result( core, '0' );
+        }
+
         /// Construct and run a pass on a translation unit.
         template< typename... Args >
@@ -96 +108 @@
         }
 
+        /// Contruct and run a pass on a pointer to extract a value.
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node, Args&&... args ) {
+                Pass<core_t> visitor( std::forward<Args>( args )... );
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
+
+        // Versions of the above for older compilers.
         template< typename... Args >
         static void run( std::list< ptr<Decl> > & decls ) {
@@ -102 +124 @@
         }
 
-        /// Storage for the actual pass
-        core_t core;
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node ) {
+                Pass<core_t> visitor;
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
 
         /// Visit function declarations
@@ -267 +294 @@
 //-------------------------------------------------------------------------------------------------
 
-/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
-
 /// If used the visitor will always clone nodes.
 struct PureVisitor {};
 
+/// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {
-        const TypeSubstitution * env = nullptr;
+        const TypeSubstitution * typeSubs = nullptr;
 };
 

src/AST/Pass.impl.hpp

@@ -154 +154 @@
                 __pedantic_pass_assert( expr );
 
-                const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0);
-                if ( env_ptr && expr->env ) {
-                        *env_ptr = expr->env;
+                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
+                if ( typeSubs_ptr && expr->env ) {
+                        *typeSubs_ptr = expr->env;
                 }
 
@@ -177 +177 @@
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( core, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::typeSubs( core, 0 ) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
@@ -465 +465 @@
                         __pass::symtab::addId( core, 0, func );
                         VISIT(
+                                // parameter declarations are now directly here
+                                maybe_accept( node, &FunctionDecl::params );
+                                maybe_accept( node, &FunctionDecl::returns );
+                                // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
                                 // function body needs to have the same scope as parameters - CompoundStmt will not enter
@@ -1488 +1492 @@
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );

src/AST/Pass.proto.hpp

@@ -236 +236 @@
 
         // List of fields and their expected types
-        FIELD_PTR( env, const ast::TypeSubstitution * )
+        FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
         FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
         FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
@@ -421 +421 @@
 
         } // namespace forall
+
+        template<typename core_t>
+        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
+                return core.result();
+        }
+
+        template<typename core_t>
+        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
+                return core.result;
+        }
+
+        template<typename core_t>
+        static inline void get_result( core_t &, long ) {}
 } // namespace __pass
 } // namespace ast

src/AST/Print.cpp

@@ -270 +270 @@
         }
 
-        void preprint( const ast::ReferenceToType * node ) {
+        void preprint( const ast::BaseInstType * node ) {
                 print( node->forall );
                 print( node->attributes );

src/AST/SymbolTable.cpp

@@ -313 +313 @@
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
-                auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
+                auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
                 assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
                         toString( expr->result ).c_str() );
@@ -335 +335 @@
 }
 
+/*
 void SymbolTable::addFunctionType( const FunctionType * ftype ) {
         addTypes( ftype->forall );
@@ -340 +341 @@
         addIds( ftype->params );
 }
+*/
 
 void SymbolTable::lazyInitScope() {
@@ -368 +370 @@
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                const Type * base = InitTweak::getPointerBase( params.front() );
                 assert( base );
                 return Mangle::mangle( base );
@@ -654 +656 @@
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
+                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;

src/AST/SymbolTable.hpp

@@ -145 +145 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        void addFunctionType( const FunctionType * ftype );
+        // void addFunctionType( const FunctionType * ftype );
 
 private:

src/AST/Type.cpp

@@ -102 +102 @@
 // --- FunctionType
 
+
 FunctionType::FunctionType( const FunctionType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
@@ -112 +113 @@
 
 namespace {
-        bool containsTtype( const std::vector<ptr<DeclWithType>> & l ) {
+        bool containsTtype( const std::vector<ptr<Type>> & l ) {
                 if ( ! l.empty() ) {
-                        return Tuples::isTtype( l.back()->get_type() );
+                        return Tuples::isTtype( l.back() );
                 }
                 return false;
@@ -124 +125 @@
 }
 
-// --- ReferenceToType
-
-void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
+// --- BaseInstType
+
+void BaseInstType::initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub ) {
         ParameterizedType::initWithSub( o, sub ); // initialize substitution
         params = sub.core( o.params );            // apply to parameters
 }
 
-ReferenceToType::ReferenceToType( const ReferenceToType & o )
+BaseInstType::BaseInstType( const BaseInstType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
   hoistType( o.hoistType ) {
@@ -138 +139 @@
 }
 
-std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
+std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
 
@@ -153 +154 @@
 SueInstType<decl_t>::SueInstType(
         const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
 template<typename decl_t>
@@ -168 +169 @@
 TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
 // --- TypeInstType
 
 TypeInstType::TypeInstType( const TypeInstType & o )
-: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
+: BaseInstType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
         Pass< ForallSubstitutor > sub;
         initWithSub( o, sub );      // initialize substitution

src/AST/Type.hpp

@@ -302 +302 @@
 class FunctionType final : public ParameterizedType {
 public:
-        std::vector<ptr<DeclWithType>> returns;
-        std::vector<ptr<DeclWithType>> params;
+//      std::vector<ptr<DeclWithType>> returns;
+//      std::vector<ptr<DeclWithType>> params;
+
+        std::vector<ptr<Type>> returns;
+        std::vector<ptr<Type>> params;
 
         /// Does the function accept a variable number of arguments following the arguments specified
@@ -329 +332 @@
 
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
-class ReferenceToType : public ParameterizedType {
+class BaseInstType : public ParameterizedType {
 protected:
         /// Initializes forall and parameters based on substitutor
-        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
+        void initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub );
 public:
         std::vector<ptr<Expr>> params;
@@ -338 +341 @@
         bool hoistType = false;
 
-        ReferenceToType(
+        BaseInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
 
-        ReferenceToType( const ReferenceToType & o );
+        BaseInstType( const BaseInstType & o );
 
         /// Gets aggregate declaration this type refers to
@@ -350 +353 @@
 
 private:
-        virtual ReferenceToType * clone() const override = 0;
+        virtual BaseInstType * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -356 +359 @@
 // Common implementation for the SUE instance types. Not to be used directly.
 template<typename decl_t>
-class SueInstType final : public ReferenceToType {
+class SueInstType final : public BaseInstType {
 public:
         using base_type = decl_t;
@@ -363 +366 @@
         SueInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base() {}
+        : BaseInstType( n, q, std::move(as) ), base() {}
 
         SueInstType(
@@ -388 +391 @@
 
 /// An instance of a trait type.
-class TraitInstType final : public ReferenceToType {
+class TraitInstType final : public BaseInstType {
 public:
         readonly<TraitDecl> base;
@@ -394 +397 @@
         TraitInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base() {}
+        : BaseInstType( n, q, std::move(as) ), base() {}
 
         TraitInstType(
@@ -411 +414 @@
 
 /// instance of named type alias (typedef or variable)
-class TypeInstType final : public ReferenceToType {
+class TypeInstType final : public BaseInstType {
 public:
         readonly<TypeDecl> base;
@@ -419 +422 @@
                 const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
+        : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
+        : BaseInstType( n, q, std::move(as) ), base(), kind( k ) {}
 
         TypeInstType( const TypeInstType & o );

src/AST/TypeSubstitution.cpp

@@ -176 +176 @@
 }
 
-void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) {
+void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers

src/AST/TypeSubstitution.hpp

@@ -169 +169 @@
                 void previsit( const ParameterizedType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                void handleAggregateType( const ReferenceToType * type );
+                void handleAggregateType( const BaseInstType * type );
 
                 void previsit( const StructInstType * aggregateUseType );

src/Common/Stats/Stats.cc

@@ -35 +35 @@
         }
 
+        namespace ResolveTime {
+                bool enabled = false;
+        }
+
         struct {
                 const char * const opt;
@@ -43 +47 @@
                 { "heap"    , Heap::enabled },
                 { "time"    , Time::enabled },
+                { "resolve" , ResolveTime::enabled },
         };
 

src/Common/module.mk

@@ -22 +22 @@
       Common/ErrorObjects.h \
       Common/Eval.cc \
+      Common/Examine.cc \
+      Common/Examine.h \
       Common/FilterCombos.h \
       Common/Indenter.h \
@@ -38 +40 @@
       Common/Stats/Heap.cc \
       Common/Stats/Heap.h \
+      Common/Stats/ResolveTime.cc \
+      Common/Stats/ResolveTime.h \
       Common/Stats/Stats.cc \
       Common/Stats/Time.cc \

src/Concurrency/Keywords.cc

@@ -19 +19 @@
 #include <string>                         // for string, operator==
 
+#include <iostream>
+
+#include "Common/Examine.h"               // for isMainFor
 #include "Common/PassVisitor.h"           // for PassVisitor
 #include "Common/SemanticError.h"         // for SemanticError
@@ -34 +37 @@
 #include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
 #include "SynTree/Visitor.h"              // for Visitor, acceptAll
+#include "Virtual/Tables.h"
 
 class Attribute;
 
 namespace Concurrency {
+        inline static std::string getVTableName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -54 +62 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
@@ -63 +75 @@
 
                 void handle( StructDecl * );
+                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
@@ -76 +89 @@
                 const std::string getter_name;
                 const std::string context_error;
+                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
@@ -81 +95 @@
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
+                StructDecl * vtable_decl = nullptr;
         };
 
@@ -101 +116 @@
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "",
                         true,
                         AggregateDecl::Thread
@@ -133 +149 @@
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
@@ -167 +184 @@
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "",
                         false,
                         AggregateDecl::Monitor
@@ -198 +216 @@
                         "get_generator",
                         "Unable to find builtin type $generator\n",
+                        "",
                         true,
                         AggregateDecl::Generator
@@ -231 +250 @@
 
         private:
-                DeclarationWithType * is_main( FunctionDecl * );
                 bool is_real_suspend( FunctionDecl * );
 
@@ -359 +377 @@
                         handle( decl );
                 }
+                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
+                        vtable_decl = decl;
+                }
+                // Might be able to get ride of is target.
+                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
         }
 
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
-                if( !type_decl ) return decl;
-                if( !CodeGen::isDestructor( decl->name ) ) return decl;
-
-                auto params = decl->type->parameters;
-                if( params.size() != 1 ) return decl;
-
-                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
-                if( !type ) return decl;
-
-                auto stype = dynamic_cast<StructInstType*>( type->base );
-                if( !stype ) return decl;
-                if( stype->baseStruct != type_decl ) return decl;
-
-                if( !dtor_decl ) dtor_decl = decl;
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+
+                        declsToAddAfter.push_back( Virtual::makeVtableInstance( vtable_decl, {
+                                new TypeExpr( struct_type->clone() ),
+                        }, struct_type, nullptr ) );
+                }
+
                 return decl;
         }
@@ -400 +426 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
+
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        declsToAddBefore.push_back( Virtual::makeVtableForward( vtable_decl, {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        } ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
         }
 
@@ -528 +566 @@
         // Suspend keyword implementation
         //=============================================================================================
-        DeclarationWithType * SuspendKeyword::is_main( FunctionDecl * func) {
-                if(func->name != "main") return nullptr;
-                if(func->type->parameters.size() != 1) return nullptr;
-
-                auto param = func->type->parameters.front();
-
-                auto type  = dynamic_cast<ReferenceType * >(param->get_type());
-                if(!type) return nullptr;
-
-                auto obj   = dynamic_cast<StructInstType *>(type->base);
-                if(!obj) return nullptr;
-
-                if(!obj->baseStruct->is_generator()) return nullptr;
-
-                return param;
-        }
-
         bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
                 if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
@@ -565 +586 @@
 
                 // Is this the main of a generator?
-                auto param = is_main( func );
+                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
                 if(!param) return;
 
@@ -910 +931 @@
                                         {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
                                         },
                                         noDesignators,
@@ -1033 +1055 @@
 // tab-width: 4 //
 // End: //
+

src/GenPoly/InstantiateGeneric.cc

@@ -172 +172 @@
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                 /// Set of types which are dtype-only generic (and therefore have static layout)
-                ScopedSet< AggregateDecl* > dtypeStatics;
+                std::set<AggregateDecl *> dtypeStatics;
                 /// Namer for concrete types
                 UniqueName typeNamer;
@@ -505 +505 @@
         void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
-                dtypeStatics.beginScope();
         }
 
         void GenericInstantiator::endScope() {
                 instantiations.endScope();
-                dtypeStatics.endScope();
         }
 

src/InitTweak/InitTweak.cc

@@ -1026 +1026 @@
                 if ( ftype->params.size() != 2 ) return false;
 
-                const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
+                const ast::Type * t1 = getPointerBase( ftype->params.front() );
                 if ( ! t1 ) return false;
-                const ast::Type * t2 = ftype->params.back()->get_type();
+                const ast::Type * t2 = ftype->params.back();
 
                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sat Feb 15 11:05:50 2020
- * Update Count     : 737
+ * Last Modified On : Tue Oct  6 18:15:41 2020
+ * Update Count     : 743
  */
 
@@ -62 +62 @@
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 
-#ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
+#ifdef HAVE_KEYWORDS_FLOATXX                                                    // GCC >= 7 => keyword, otherwise typedef
 #define FLOATXX(v) KEYWORD_RETURN(v);
 #else
@@ -292 +292 @@
 __restrict__    { KEYWORD_RETURN(RESTRICT); }                   // GCC
 return                  { KEYWORD_RETURN(RETURN); }
-        /* resume                       { KEYWORD_RETURN(RESUME); }                             // CFA */
+ /* resume                      { KEYWORD_RETURN(RESUME); }                             // CFA */
 short                   { KEYWORD_RETURN(SHORT); }
 signed                  { KEYWORD_RETURN(SIGNED); }

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May 28 12:11:45 2020
-// Update Count     : 4500
+// Last Modified On : Tue Oct  6 18:24:18 2020
+// Update Count     : 4610
 //
 
@@ -278 +278 @@
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
-// %token RESUME                                                                        // CFA
-%token SUSPEND                                                                  // CFA
+// %token RESUME                                                                                        // CFA
+%token SUSPEND                                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
@@ -329 +329 @@
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
-%type<en> argument_expression_list_opt          argument_expression                     default_initialize_opt
+%type<en> argument_expression_list_opt  argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
@@ -370 +370 @@
 %type<decl> assertion assertion_list assertion_list_opt
 
-%type<en>   bit_subrange_size_opt bit_subrange_size
+%type<en> bit_subrange_size_opt bit_subrange_size
 
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
@@ -793 +793 @@
         | '(' aggregate_control '&' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
-                // VIRTUAL cannot be opt because of look ahead issues
         | '(' VIRTUAL ')' cast_expression                                       // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $4 ), maybeMoveBuildType( nullptr ) ) ); }
@@ -920 +919 @@
         | unary_expression assignment_operator assignment_expression
                 {
-                        if ( $2 == OperKinds::AtAssn ) {
-                                SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
-                        } else {
+//                      if ( $2 == OperKinds::AtAssn ) {
+//                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
+//                      } else {
                                 $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
-                        } // if
+//                      } // if
                 }
         | unary_expression '=' '{' initializer_list_opt comma_opt '}'
@@ -1676 +1675 @@
 
 typedef_expression:
-                // GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
+                // deprecated GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
         TYPEDEF identifier '=' assignment_expression
                 {
-                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
-                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
                 }
         | typedef_expression pop ',' push identifier '=' assignment_expression
                 {
-                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
-                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
-                }
-        ;
-
-//c_declaration:
-//      declaring_list pop ';'
-//      | typedef_declaration pop ';'
-//      | typedef_expression pop ';'                                            // GCC, naming expression type
-//      | sue_declaration_specifier pop ';'
-//      ;
-//
-//declaring_list:
-//              // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
-//              // storage-class
-//       declarator asm_name_opt initializer_opt
-//              {
-//                      typedefTable.addToEnclosingScope( IDENTIFIER );
-//                      $$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
-//              }
-//      | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
-//              {
-//                      typedefTable.addToEnclosingScope( IDENTIFIER );
-//                      $$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
-//              }
-//      ;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
+        ;
 
 c_declaration:
@@ -1715 +1690 @@
                 { $$ = distAttr( $1, $2 ); }
         | typedef_declaration
-        | typedef_expression                                                            // GCC, naming expression type
+        | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
         ;
@@ -2094 +2069 @@
                 { yyy = true; $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
-                { yyy = true; $$ = AggregateDecl::Exception; }
+                // { yyy = true; $$ = AggregateDecl::Exception; }
+                { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         ;
 

src/ResolvExpr/CandidateFinder.cpp

@@ -188 +188 @@
 
                         // mark conversion cost and also specialization cost of param type
-                        const ast::Type * paramType = (*param)->get_type();
+                        // const ast::Type * paramType = (*param)->get_type();
                         cand->expr = ast::mutate_field_index(
                                 appExpr, &ast::ApplicationExpr::args, i,
                                 computeExpressionConversionCost(
-                                        args[i], paramType, symtab, cand->env, convCost ) );
-                        convCost.decSpec( specCost( paramType ) );
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
                         ++param;  // can't be in for-loop update because of the continue
                 }
@@ -698 +698 @@
                         if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
                                 // attempt to narrow based on expected target type
-                                const ast::Type * returnType = funcType->returns.front()->get_type();
+                                const ast::Type * returnType = funcType->returns.front();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
@@ -712 +712 @@
                         std::size_t genStart = 0;
 
-                        for ( const ast::DeclWithType * param : funcType->params ) {
-                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
+                        // xxx - how to handle default arg after change to ftype representation?
+                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                        // function may have default args only if directly calling by name
+                                        // must use types on candidate however, due to RenameVars substitution
+                                        auto nParams = funcType->params.size();
+
+                                        for (size_t i=0; i<nParams; ++i) {
+                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                                if (!instantiateArgument(
+                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
+                                        goto endMatch;
+                                }
+                        }
+                        for ( const auto & param : funcType->params ) {
                                 // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
+                                // no default args for indirect calls
                                 if ( ! instantiateArgument(
-                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
-                        }
-
+                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
+
+                        endMatch:
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack
@@ -816 +832 @@
                 /// Adds aggregate member interpretations
                 void addAggMembers(
-                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
+                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
@@ -1263 +1279 @@
 
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        const ast::ReferenceToType * aggInst;
+                        const ast::BaseInstType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;

src/ResolvExpr/ConversionCost.cc

@@ -520 +520 @@
                 return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
         } else {
-                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
-                src->accept( converter );
-                return converter.core.cost;
+                return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
         }
 }
@@ -563 +561 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
-                        src->accept( converter );
-                        return converter.core.cost;
+                        return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
                 }
         } else {

src/ResolvExpr/ConversionCost.h

@@ -88 +88 @@
         static size_t traceId;
         Cost cost;
+        Cost result() { return cost; }
 
         ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,

src/ResolvExpr/CurrentObject.cc

@@ -594 +594 @@
         class SimpleIterator final : public MemberIterator {
                 CodeLocation location;
-                readonly< Type > type = nullptr;
+                const Type * type = nullptr;
         public:
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
@@ -630 +630 @@
         class ArrayIterator final : public MemberIterator {
                 CodeLocation location;
-                readonly< ArrayType > array = nullptr;
-                readonly< Type > base = nullptr;
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
@@ -923 +923 @@
 
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
-                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
+                if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
                                 return new StructIterator{ loc, sit };
@@ -932 +932 @@
                                         dynamic_cast< const EnumInstType * >( type )
                                                 || dynamic_cast< const TypeInstType * >( type ),
-                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
+                                        "Encountered unhandled BaseInstType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
                                 return new SimpleIterator{ loc, type };
@@ -965 +965 @@
                                         DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
-                                        if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
+                                        if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
                                                 // concatenate identical field names
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
+#include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "InitTweak/GenInit.h"
@@ -965 +966 @@
                 /// Finds deleted expressions in an expression tree
                 struct DeleteFinder_new final : public ast::WithShortCircuiting {
-                        const ast::DeletedExpr * delExpr = nullptr;
+                        const ast::DeletedExpr * result = nullptr;
 
                         void previsit( const ast::DeletedExpr * expr ) {
-                                if ( delExpr ) { visit_children = false; }
-                                else { delExpr = expr; }
+                                if ( result ) { visit_children = false; }
+                                else { result = expr; }
                         }
 
                         void previsit( const ast::Expr * ) {
-                                if ( delExpr ) { visit_children = false; }
+                                if ( result ) { visit_children = false; }
                         }
                 };
@@ -980 +981 @@
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
-                ast::Pass<DeleteFinder_new> finder;
-                expr->accept( finder );
-                return finder.core.delExpr;
+                return ast::Pass<DeleteFinder_new>::read( expr );
         }
 
@@ -1171 +1170 @@
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
-                        return findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::start( untyped );
+                        auto res = findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::stop();
+                        return res;
                 }
         } // anonymous namespace
@@ -1221 +1223 @@
                 template<typename Iter>
                 inline bool nextMutex( Iter & it, const Iter & end ) {
-                        while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
+                        while ( it != end && ! (*it)->is_mutex() ) { ++it; }
                         return it != end;
                 }
@@ -1261 +1263 @@
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
+                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
 
@@ -1493 +1496 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // TODO: This will need a fix for the decl/cond scoping problem.
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // holds, check it. This allows a check for when to decode the mangling.
+                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
-                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
-                        catchStmt = ast::mutate_field(
-                                catchStmt, &ast::CatchStmt::cond,
-                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
+                        ast::CatchStmt * stmt = mutate( catchStmt );
+                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
+                        stmt->cond = nullptr;
+                        return stmt;
+                }
+                return catchStmt;
+        }
+
+        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->cond );
+                        assert( ifStmt->elsePart );
+                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
+                        stmt->cond = ifStmt->cond;
+                        stmt->body = ifStmt->elsePart;
+                        // ifStmt should be implicately deleted here.
+                        return stmt;
                 }
                 return catchStmt;
@@ -1615 +1638 @@
                                                                 // Check if the argument matches the parameter type in the current
                                                                 // scope
-                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
+                                                                // ast::ptr< ast::Type > paramType = (*param)->get_type();
                                                                 if (
                                                                         ! unify(
-                                                                                arg->expr->result, paramType, resultEnv, need, have, open,
+                                                                                arg->expr->result, *param, resultEnv, need, have, open,
                                                                                 symtab )
                                                                 ) {
@@ -1625 +1648 @@
                                                                         ss << "candidate function not viable: no known conversion "
                                                                                 "from '";
-                                                                        ast::print( ss, (*param)->get_type() );
+                                                                        ast::print( ss, *param );
                                                                         ss << "' to '";
                                                                         ast::print( ss, arg->expr->result );

src/ResolvExpr/SatisfyAssertions.cpp

@@ -318 +318 @@
                                         if ( ! func ) continue;
 
-                                        for ( const ast::DeclWithType * param : func->params ) {
-                                                cost.decSpec( specCost( param->get_type() ) );
+                                        for ( const auto & param : func->params ) {
+                                                cost.decSpec( specCost( param ) );
                                         }
 

src/ResolvExpr/SpecCost.cc

@@ -178 +178 @@
                 void previsit( const ast::FunctionType * fty ) {
                         int minCount = std::numeric_limits<int>::max();
-                        updateMinimumPresent( minCount, fty->params, decl_type );
-                        updateMinimumPresent( minCount, fty->returns, decl_type );
+                        updateMinimumPresent( minCount, fty->params, type_deref );
+                        updateMinimumPresent( minCount, fty->returns, type_deref );
                         // Add another level to minCount if set.
                         count = toNoneOrInc( minCount );

src/ResolvExpr/Unify.cc

@@ -395 +395 @@
 
         template< typename Iterator1, typename Iterator2 >
-        bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
@@ -489 +489 @@
                                         || flatOther->isTtype()
                         ) {
-                                if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-                                        if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
 
                                                 // the original types must be used in mark assertions, since pointer comparisons are used
@@ -784 +784 @@
 
                 /// returns flattened version of `src`
-                static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
-                        const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
+                static std::vector< ast::ptr< ast::Type > > flattenList(
+                        const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
                 ) {
-                        std::vector< ast::ptr< ast::DeclWithType > > dst;
+                        std::vector< ast::ptr< ast::Type > > dst;
                         dst.reserve( src.size() );
-                        for ( const ast::DeclWithType * d : src ) {
+                        for ( const auto & d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
                                 // TtypeExpander pass is impure (may mutate nodes in place)
                                 // need to make nodes shared to prevent accidental mutation
-                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
-                                auto types = flatten( dc->get_type() );
+                                ast::ptr<ast::Type> dc = d->accept(expander);
+                                auto types = flatten( dc );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
@@ -803 +803 @@
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
-                                        dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
+                                        dst.emplace_back( t );
                                 }
                         }
@@ -811 +811 @@
                 /// Creates a tuple type based on a list of DeclWithType
                 template< typename Iter >
-                static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
+                static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
                         std::vector< ast::ptr< ast::Type > > types;
                         while ( crnt != end ) {
                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
                                 // that this results in a flat tuple
-                                flatten( (*crnt)->get_type(), types );
+                                flatten( *crnt, types );
 
                                 ++crnt;
@@ -825 +825 @@
 
                 template< typename Iter >
-                static bool unifyDeclList(
+                static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
@@ -831 +831 @@
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
-                                const ast::Type * t1 = (*crnt1)->get_type();
-                                const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t1 = *crnt1;
+                                const ast::Type * t2 = *crnt2;
                                 bool isTuple1 = Tuples::isTtype( t1 );
                                 bool isTuple2 = Tuples::isTtype( t2 );
@@ -840 +840 @@
                                         // combine remainder of list2, then unify
                                         return unifyExact(
-                                                t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                                t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                                 noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
-                                                tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                                tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
                                 }
@@ -860 +860 @@
                         if ( crnt1 != end1 ) {
                                 // try unifying empty tuple with ttype
-                                const ast::Type * t1 = (*crnt1)->get_type();
+                                const ast::Type * t1 = *crnt1;
                                 if ( ! Tuples::isTtype( t1 ) ) return false;
                                 return unifyExact(
-                                        t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                        t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                         noWiden(), symtab );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
-                                const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t2 = *crnt2;
                                 if ( ! Tuples::isTtype( t2 ) ) return false;
                                 return unifyExact(
-                                        tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                        tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                         noWiden(), symtab );
                         }
@@ -877 +877 @@
                 }
 
-                static bool unifyDeclList(
-                        const std::vector< ast::ptr< ast::DeclWithType > > & list1,
-                        const std::vector< ast::ptr< ast::DeclWithType > > & list2,
+                static bool unifyTypeList(
+                        const std::vector< ast::ptr< ast::Type > > & list1,
+                        const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
                 ) {
-                        return unifyDeclList(
+                        return unifyTypeList(
                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
                                 symtab );
@@ -928 +928 @@
                         ) return;
 
-                        if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
-                        if ( ! unifyDeclList(
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList(
                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
 
@@ -1232 +1232 @@
         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
                 if ( func->returns.empty() ) return new ast::VoidType{};
-                if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+                if ( func->returns.size() == 1 ) return func->returns[0];
 
                 std::vector<ast::ptr<ast::Type>> tys;
-                for ( const ast::DeclWithType * decl : func->returns ) {
-                        tys.emplace_back( decl->get_type() );
+                for ( const auto & decl : func->returns ) {
+                        tys.emplace_back( decl );
                 }
                 return new ast::TupleType{ std::move(tys) };

src/SymTab/Mangler.cc

@@ -437 +437 @@
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
-                        void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
+                        void mangleRef( const ast::BaseInstType *refType, std::string prefix );
 
                         void printQualifiers( const ast::Type *type );
@@ -551 +551 @@
                         GuardValue( inFunctionType );
                         inFunctionType = true;
-                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
-                        if (returnTypes.empty()) mangleName << Encoding::void_t;
-                        else accept_each( returnTypes, *visitor );
+                        if (functionType->returns.empty()) mangleName << Encoding::void_t;
+                        else accept_each( functionType->returns, *visitor );
                         mangleName << "_";
-                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
-                        accept_each( paramTypes, *visitor );
+                        accept_each( functionType->params, *visitor );
                         mangleName << "_";
                 }
 
-                void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
+                void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
                         printQualifiers( refType );
 

src/SymTab/Validate.cc

@@ -960 +960 @@
         }
 
+        static bool isNonParameterAttribute( Attribute * attr ) {
+                static const std::vector<std::string> bad_names = {
+                        "aligned", "__aligned__",
+                };
+                for ( auto name : bad_names ) {
+                        if ( name == attr->name ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
         Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
@@ -968 +980 @@
                         ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
-                        // attributes are not carried over from typedef to function parameters/return values
-                        if ( ! inFunctionType ) {
-                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
-                        } else {
-                                deleteAll( ret->attributes );
-                                ret->attributes.clear();
-                        }
+                        // GCC ignores certain attributes if they arrive by typedef, this mimics that.
+                        if ( inFunctionType ) {
+                                ret->attributes.remove_if( isNonParameterAttribute );
+                        }
+                        ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
@@ -1374 +1384 @@
         /// Replaces enum types by int, and function/array types in function parameter and return
         /// lists by appropriate pointers
+        /*
         struct EnumAndPointerDecay_new {
                 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
@@ -1424 +1435 @@
                 }
         };
+        */
 
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
@@ -1508 +1520 @@
                 }
 
-                void checkGenericParameters( const ast::ReferenceToType * inst ) {
+                void checkGenericParameters( const ast::BaseInstType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
@@ -1827 +1839 @@
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
-        ast::Pass< EnumAndPointerDecay_new > epc;
+        // ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
         ast::Pass< ForallPointerDecay_new > fpd{ loc };
 
-        return type->accept( epc )->accept( lrt )->accept( fpd );
+        return type->accept( lrt )->accept( fpd );
 }
 

src/Virtual/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h
+SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h \
+        Virtual/Tables.cc Virtual/Tables.h
+
+SRCDEMANGLE += Virtual/Tables.cc