Changes in / [05d55ff:be8518f]

Location:

src

Files:

• AST/Convert.cpp (modified) (6 diffs)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (5 diffs)
• AST/GenericSubstitution.cpp (modified) (2 diffs)
• AST/GenericSubstitution.hpp (modified) (1 diff)
• AST/Init.hpp (modified) (2 diffs)
• AST/Node.hpp (modified) (4 diffs)
• AST/porting.md (modified) (1 diff)
• ResolvExpr/CurrentObject.cc (modified) (5 diffs)
• ResolvExpr/CurrentObject.h (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (8 diffs)

src/AST/Convert.cpp

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

src/AST/Expr.cpp

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

src/AST/Expr.hpp

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

src/AST/GenericSubstitution.cpp

@@ -31 +31 @@
                 TypeSubstitution sub;
 
-                void previsit( const Type * ) {
-                        // allow empty substitution for non-generic type
-                        visit_children = false;
+                void previsit( const Type * ty ) {
+                        assertf( false, "Attempted generic substitution for non-aggregate type: %s",
+                                toString( ty ).c_str() );
                 }
 
@@ -40 +40 @@
                 }
 
-        private:
-                // make substitution for generic type
-                void makeSub( const ReferenceToType * ty ) {
+                void previsit( const ReferenceToType * ty ) {
                         visit_children = false;
+                        // build substitution from base parameters
                         const AggregateDecl * aggr = ty->aggr();
                         sub = TypeSubstitution{ aggr->params.begin(), aggr->params.end(), ty->params.begin() };
-                }
-
-        public:
-                void previsit( const StructInstType * ty ) {
-                        makeSub( ty );
-                }
-
-                void previsit( const UnionInstType * ty ) {
-                        makeSub( ty );
                 }
         };
 }
 
-TypeSubstitution genericSubstitution( const Type * ty ) {
+TypeSubstitution genericSubsitution( const Type * ty ) {
         Pass<GenericSubstitutionBuilder> builder;
         maybe_accept( ty, builder );

src/AST/GenericSubstitution.hpp

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

src/AST/Init.hpp

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

src/AST/Node.hpp

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

src/AST/porting.md

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

src/ResolvExpr/CurrentObject.cc

@@ -16 +16 @@
 #include <stddef.h>                    // for size_t
 #include <cassert>                     // for assertf, assert, safe_dynamic_...
-#include <deque>
 #include <iostream>                    // for ostream, operator<<, basic_ost...
 #include <stack>                       // for stack
@@ -22 +21 @@
 
 #include "AST/Expr.hpp"                // for InitAlternative
-#include "AST/GenericSubstitution.hpp" // for genericSubstitution
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
-#include "AST/Type.hpp"
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError
@@ -586 +583 @@
 
 namespace ast {
-        /// create a new MemberIterator that traverses a type correctly
-        MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
+
+        /// Iterates members of a type by initializer
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+
+                /// retrieve the list of possible (Type,Designation) pairs for the current position in the 
+                /// current object
+                virtual std::vector< InitAlternative > operator* () const = 0;
+        
+        protected:
+                /// helper for operator*; aggregates must add designator to each init alternative, but 
+                /// adding designators in operator* creates duplicates
+                virtual std::vector< InitAlternative > first() const = 0;
+        };
 
         /// Iterates "other" types (e.g. basic, pointer) which do not change at list initializer entry
@@ -596 +606 @@
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
 
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
-                        std::deque< ptr< Expr > >::const_iterator end
-                ) override {
-                        if ( begin != end ) {
-                                SemanticError( location, "Un-designated initializer given non-empty designator" );
-                        }
-                }
-
-                std::deque< InitAlternative > operator* () const override { return first(); }
-
-                operator bool() const override { return type; }
-
-                SimpleIterator & bigStep() override { return smallStep(); }
-                SimpleIterator & smallStep() override {
-                        type = nullptr;  // empty on increment because no members
-                        return *this;
-                }
-
-                const Type * getType() override { return type; }
-
-                const Type * getNext() override { return type; }
-
-                std::deque< InitAlternative > first() const override {
+                std::vector< InitAlternative > operator* () const override { return first(); }
+
+        protected:
+                std::vector< InitAlternative > first() const override {
                         if ( type ) return { InitAlternative{ type, new Designation{ location } } };
                         return {};
@@ -625 +615 @@
         };
 
-        /// Iterates array types
-        class ArrayIterator final : public MemberIterator {
-                CodeLocation location;
-                readonly< ArrayType > array = nullptr;
-                readonly< Type > base = nullptr;
-                size_t index = 0;
-                size_t size = 0;
-                std::unique_ptr< MemberIterator > memberIter;
-
-                void setSize( const Expr * expr ) {
-                        auto res = eval(expr);
-                        if ( ! res.second ) {
-                                SemanticError( location, 
-                                        toString("Array designator must be a constant expression: ", expr ) );
-                        }
-                        size = res.first;
-                }
-
-        public:
-                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) 
-                : location( loc ), array( at ), base( at->base ) {
-                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
-                        memberIter.reset( createMemberIterator( loc, base ) );
-                        if ( at->isVarLen ) {
-                                SemanticError( location, at, "VLA initialization does not support @=: " );
-                        }
-                        setSize( at->dimension );
-                }
-
-                void setPosition( const Expr * expr ) {
-                        // need to permit integer-constant-expressions, including: integer constants, 
-                        // enumeration constants, character constants, sizeof expressions, alignof expressions, 
-                        // cast expressions
-                        if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
-                                try {
-                                        index = constExpr->intValue();
-                                } catch ( SemanticErrorException & ) {
-                                        SemanticError( expr, 
-                                                "Constant expression of non-integral type in array designator: " );
-                                }
-                        } else if ( auto castExpr = dynamic_cast< const CastExpr * >( expr ) ) {
-                                setPosition( castExpr->arg );
-                        } else if ( 
-                                dynamic_cast< const SizeofExpr * >( expr ) 
-                                || dynamic_cast< const AlignofExpr * >( expr ) 
-                        ) {
-                                index = 0;
-                        } else {
-                                assertf( false, 
-                                        "bad designator given to ArrayIterator: %s", toString( expr ).c_str() );
-                        }
-                }
-
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
-                        std::deque< ptr< Expr > >::const_iterator end
-                ) override {
-                        if ( begin == end ) return;
-
-                        setPosition( *begin );
-                        memberIter->setPosition( ++begin, end );
-                }
-
-                std::deque< InitAlternative > operator* () const override { return first(); }
-
-                operator bool() const override { return index < size; }
-
-                ArrayIterator & bigStep() override {
-                        PRINT( std::cerr << "bigStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        ++index;
-                        memberIter.reset( index < size ? createMemberIterator( location, base ) : nullptr );
-                        return *this;
-                }
-
-                ArrayIterator & smallStep() override {
-                        PRINT( std::cerr << "smallStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        if ( memberIter ) {
-                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
-                                memberIter->smallStep();
-                                if ( *memberIter ) {
-                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
-                                        return *this;
-                                }
-                        }
-                        return bigStep();
-                }
-
-                const Type * getType() override { return array; }
-
-                const Type * getNext() override { return base; }
-
-                std::deque< InitAlternative > first() const override {
-                        PRINT( std::cerr << "first in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        if ( memberIter && *memberIter ) {
-                                std::deque< InitAlternative > ret = memberIter->first();
-                                for ( InitAlternative & alt : ret ) {
-                                        alt.designation.get_and_mutate()->designators.emplace_front(
-                                                ConstantExpr::from_ulong( location, index ) );
-                                }
-                                return ret;
-                        }
-                        return {};
-                }
-        };
-
-        class AggregateIterator : public MemberIterator {
-        protected:
-                using MemberList = std::vector< ptr< Decl > >;
-
-                CodeLocation location;
-                std::string kind;  // for debug
-                std::string name;
-                const Type * inst;
-                const MemberList & members;
-                MemberList::const_iterator curMember;
-                bool atbegin = true;  // false at first {small,big}Step
-                const Type * curType = nullptr;
-                std::unique_ptr< MemberIterator > memberIter = nullptr;
-                TypeSubstitution sub;
-
-                bool init() {
-                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
-                        if ( curMember != members.end() ) {
-                                if ( auto field = curMember->as< ObjectDecl >() ) {
-                                        PRINT( std::cerr << "incremented to field: " << field << std::endl; )
-                                        curType = field->get_type();
-                                        memberIter.reset( createMemberIterator( location, curType ) );
-                                        return true;
-                                }
-                        }
-                        return false;
-                }
-
-                AggregateIterator( 
-                        const CodeLocation & loc, const std::string k, const std::string & n, const Type * i, 
-                        const MemberList & ms )
-                : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ), 
-                  sub( genericSubstitution( i ) ) {
-                        PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
-                        init();
-                }
-
-        public:
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
-                        std::deque< ptr< Expr > >::const_iterator end
-                ) final {
-                        if ( begin == end ) return;
-
-                        if ( auto varExpr = begin->as< VariableExpr >() ) {
-                                for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
-                                        if ( *curMember != varExpr->var ) continue;
-
-                                        ++begin;
-
-                                        memberIter.reset( createMemberIterator( location, varExpr->result ) );
-                                        curType = varExpr->result;
-                                        atbegin = curMember == members.begin() && begin == end;
-                                        memberIter->setPosition( begin, end );
-                                        return;
-                                }
-                                assertf( false, 
-                                        "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
-                        } else {
-                                assertf( false, 
-                                        "bad designator given to %s: %s", kind.c_str(), toString( *begin ).c_str() );
-                        }
-                }
-
-                std::deque< InitAlternative > operator* () const final {
-                        if ( memberIter && *memberIter ) {
-                                std::deque< InitAlternative > ret = memberIter->first();
-                                PRINT( std::cerr << "sub: " << sub << std::endl; )
-                                for ( InitAlternative & alt : ret ) {
-                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation.get_and_mutate()->designators.emplace_front(
-                                                new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
-                                        // need to substitute for generic types so that casts are to concrete types
-                                        PRINT( std::cerr << "  type is: " << alt.type; )
-                                        sub.apply( alt.type ); // also apply to designation??
-                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
-                                }
-                                return ret;
-                        }
-                        return {};
-                }
-
-                AggregateIterator & smallStep() final {
-                        PRINT( std::cerr << "smallStep in " << kind << std::endl; )
-                        atbegin = false;
-                        if ( memberIter ) {
-                                PRINT( std::cerr << "has member iter, incrementing..." << std::endl; )
-                                memberIter->smallStep();
-                                if ( *memberIter ) {
-                                        PRINT( std::cerr << "success!" << std::endl; )
-                                        return *this;
-                                }
-                        }
-                        return bigStep();
-                }
-
-                AggregateIterator & bigStep() override = 0;
-
-                const Type * getType() final { return inst; }
-
-                const Type * getNext() final {
-                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
-                }
-
-                std::deque< InitAlternative > first() const final {
-                        std::deque< InitAlternative > ret;
-                        PRINT( std::cerr << "first " << kind << std::endl; )
-                        if ( memberIter && *memberIter ) {
-                                PRINT( std::cerr << "adding children" << std::endl; )
-                                ret = memberIter->first();
-                                for ( InitAlternative & alt : ret ) {
-                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation.get_and_mutate()->designators.emplace_front( 
-                                                new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
-                                }
-                        }
-                        if ( atbegin ) {
-                                // only add self if at the very beginning of the structure
-                                PRINT( std::cerr << "adding self" << std::endl; )
-                                ret.emplace_front( inst, new Designation{ location } );
-                        }
-                        return ret;
-                }
-        };
-
-        class StructIterator final : public AggregateIterator {
-        public:
-                StructIterator( const CodeLocation & loc, const StructInstType * inst )
-                : AggregateIterator( loc, "StructIterator", inst->name, inst, inst->base->members ) {}
-
-                operator bool() const override {
-                        return curMember != members.end() || (memberIter && *memberIter);
-                }
-
-                StructIterator & bigStep() override {
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        while ( curMember != members.end() ) {
-                                ++curMember;
-                                if ( init() ) return *this;
-                        }
-                        return *this;
-                }
-        };
-
-        class UnionIterator final : public AggregateIterator {
-        public:
-                UnionIterator( const CodeLocation & loc, const UnionInstType * inst )
-                : AggregateIterator( loc, "UnionIterator", inst->name, inst, inst->base->members ) {}
-
-                operator bool() const override { return memberIter && *memberIter; }
-
-                UnionIterator & bigStep() override {
-                        // unions only initialize one member
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        curMember = members.end();
-                        return *this;
-                }
-        };
-
-        class TupleIterator final : public AggregateIterator {
-        public:
-                TupleIterator( const CodeLocation & loc, const TupleType * inst ) 
-                : AggregateIterator( 
-                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members 
-                ) {}
-
-                operator bool() const override {
-                        return curMember != members.end() || (memberIter && *memberIter);
-                }
-
-                TupleIterator & bigStep() override {
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        while ( curMember != members.end() ) {
-                                ++curMember;
-                                if ( init() ) return *this;
-                        }
-                        return *this;
-                }
-        };
-
-        MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
-                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
-                        if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
-                                return new StructIterator{ loc, sit };
-                        } else if ( auto uit = dynamic_cast< const UnionInstType * >( aggr ) ) {
-                                return new UnionIterator{ loc, uit };
-                        } else {
-                                assertf( 
-                                        dynamic_cast< const EnumInstType * >( aggr ) 
-                                                || dynamic_cast< const TypeInstType * >( aggr ), 
-                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
-                                                toString( type ).c_str() );
-                                return new SimpleIterator{ loc, type };
-                        }
-                } else if ( auto at = dynamic_cast< const ArrayType * >( type ) ) {
-                        return new ArrayIterator{ loc, at };
-                } else if ( auto tt = dynamic_cast< const TupleType * >( type ) ) {
-                        return new TupleIterator{ loc, tt };
-                } else {
-                        return new SimpleIterator{ loc, type };
-                }
-        }
-
         CurrentObject::CurrentObject( const CodeLocation & loc, const Type * type ) : objStack() {
                 objStack.emplace_back( new SimpleIterator{ loc, type } );
         }
 
-        void CurrentObject::setNext( const ast::Designation * designation ) {
-                PRINT( std::cerr << "____setNext" << designation << std::endl; )
-                assertf( ! objStack.empty(), "obj stack empty in setNext" );
-                objStack.back()->setPosition( designation->designators );
-        }
-
-        void CurrentObject::increment() {
-                PRINT( std::cerr << "____increment" << std::endl; )
-                if ( objStack.empty() ) return;
-                PRINT( std::cerr << *objStack.back() << std::endl; )
-                objStack.back()->smallStep();
-        }
-
-        void CurrentObject::enterListInit( const CodeLocation & loc ) {
-                PRINT( std::cerr << "____entering list init" << std::endl; )
-                assertf( ! objStack.empty(), "empty obj stack entering list init" );
-                const ast::Type * type = objStack.back()->getNext();
-                assert( type );
-                objStack.emplace_back( createMemberIterator( loc, type ) );
-        }
-
-        void CurrentObject::exitListInit() {
-                PRINT( std::cerr << "____exiting list init" << std::endl; )
-                assertf( ! objStack.empty(), "objstack empty" );
-                objStack.pop_back();
-                if ( ! objStack.empty() ) {
-                        PRINT( std::cerr << *objStack.back() << std::endl; )
-                        objStack.back()->bigStep();
-                }
-        }
-
-        std::deque< InitAlternative > CurrentObject::getOptions() {
+        std::vector< InitAlternative > CurrentObject::getOptions() {
                 PRINT( std::cerr << "____getting current options" << std::endl; )
                 assertf( ! objStack.empty(), "objstack empty in getOptions" );
                 return **objStack.back();
-        }
-
-        const Type * CurrentObject::getCurrentType() {
-                PRINT( std::cerr << "____getting current type" << std::endl; )
-                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
-                return objStack.back()->getNext();
         }
 }

src/ResolvExpr/CurrentObject.h

@@ -16 +16 @@
 #pragma once
 
-#include <deque>
 #include <list>   // for list
 #include <memory> // for unique_ptr
@@ -22 +21 @@
 #include <vector>
 
-#include "AST/Node.hpp"  // for ptr
 #include "Common/CodeLocation.h"
 
@@ -61 +59 @@
         // AST class types
         class Designation;
-        struct InitAlternative;
+        class InitAlternative;
         class Type;
 
-        /// Iterates members of a type by initializer
-        class MemberIterator {
-        public:
-                virtual ~MemberIterator() {}
-
-                /// Internal set position based on iterator ranges
-                virtual void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator it, 
-                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
-
-                /// walks the current object using the given designators as a guide
-                void setPosition( const std::deque< ptr< Expr > > & designators ) {
-                        setPosition( designators.begin(), designators.end() );
-                }
-
-                /// retrieve the list of possible (Type,Designation) pairs for the current position in the 
-                /// current object
-                virtual std::deque< InitAlternative > operator* () const = 0;
-
-                /// true if the iterator is not currently at the end
-                virtual operator bool() const = 0;
-
-                /// moves the iterator by one member in the current object
-                virtual MemberIterator & bigStep() = 0;
-
-                /// moves the iterator by one member in the current subobject
-                virtual MemberIterator & smallStep() = 0;
-
-                /// the type of the current object
-                virtual const Type * getType() = 0;
-
-                /// the type of the current subobject
-                virtual const Type * getNext() = 0;
-        
-                /// helper for operator*; aggregates must add designator to each init alternative, but 
-                /// adding designators in operator* creates duplicates
-                virtual std::deque< InitAlternative > first() const = 0;
-        };
+        // forward declaration of internal detail
+        class MemberIterator;
 
         /// Builds initializer lists in resolution
@@ -111 +73 @@
                 CurrentObject( const CodeLocation & loc, const Type * type );
 
-                /// sets current position using the resolved designation
-                void setNext( const ast::Designation * designation );
-                /// steps to next sub-object of current object
-                void increment();
-                /// sets new current object for the duration of this brace-enclosed intializer-list
-                void enterListInit( const CodeLocation & loc );
-                /// restores previous current object
-                void exitListInit();
                 /// produces a list of alternatives (Type *, Designation *) for the current sub-object's 
                 /// initializer.
-                std::deque< InitAlternative > getOptions();
-                /// produces the type of the current object but no subobjects
-                const Type * getCurrentType();
+                std::vector< InitAlternative > getOptions();
         };
 } // namespace ast

src/ResolvExpr/Resolver.cc

@@ -781 +781 @@
         }
 
-        bool isCharType( Type * t ) {
+        template< typename T >
+        bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
@@ -1070 +1071 @@
                 };
 
-                /// Swaps argument into expression pointer, saving original environment
-                void swap_and_save_env( ast::ptr< ast::Expr > & expr, const ast::Expr * newExpr ) {
-                        ast::ptr< ast::TypeSubstitution > env = expr->env;
-                        expr.set_and_mutate( newExpr )->env = env;
-                }
-
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
                 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
@@ -1081 +1076 @@
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
                                         // cast is to the same type as its argument, remove it
-                                        swap_and_save_env( expr, castExpr->arg );
+                                        ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                        expr.set_and_mutate( castExpr->arg )->env = env;
                                 }
                         }
@@ -1179 +1175 @@
                         return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
                 }
-
-                /// check if a type is a character type
-                bool isCharType( const ast::Type * t ) {
-                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
-                                return bt->kind == ast::BasicType::Char 
-                                        || bt->kind == ast::BasicType::SignedChar 
-                                        || bt->kind == ast::BasicType::UnsignedChar;
-                        }
-                        return false;
-                }
         }
 
@@ -1227 +1213 @@
                 void previsit( const ast::WaitForStmt * );
 
-                const ast::SingleInit * previsit( const ast::SingleInit * );
-                const ast::ListInit * previsit( const ast::ListInit * );
+                void previsit( const ast::SingleInit * );
+                void previsit( const ast::ListInit * );
                 void previsit( const ast::ConstructorInit * );
         };
@@ -1377 +1363 @@
         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 if ( caseStmt->cond ) {
-                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
+                        std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
                                 "expression." );
@@ -1388 +1374 @@
                         // whether it would perform a conversion.
                         if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
-                                swap_and_save_env( newExpr, castExpr->arg );
+                                ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                newExpr.set_and_mutate( castExpr->arg )->env = env;
                         }
                         
@@ -1451 +1438 @@
         }
 
-
-
-        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
-                visit_children = false;
-                // resolve initialization using the possibilities as determined by the `currentObject` 
-                // cursor.
-                ast::Expr * untyped = new ast::UntypedInitExpr{ 
-                        singleInit->location, singleInit->value, currentObject.getOptions() };
-                ast::ptr<ast::Expr> newExpr = findKindExpression( untyped, symtab );
-                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
-
-                // move cursor to the object that is actually initialized
-                currentObject.setNext( initExpr->designation );
-
-                // discard InitExpr wrapper and retain relevant pieces.
-                // `initExpr` may have inferred params in the case where the expression specialized a 
-                // function pointer, and newExpr may already have inferParams of its own, so a simple 
-                // swap is not sufficient
-                ast::Expr::InferUnion inferred = initExpr->inferred;
-                swap_and_save_env( newExpr, initExpr->expr );
-                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
-
-                // get the actual object's type (may not exactly match what comes back from the resolver 
-                // due to conversions)
-                const ast::Type * initContext = currentObject.getCurrentType();
-
-                removeExtraneousCast( newExpr, symtab );
-
-                // check if actual object's type is char[]
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( initContext ) ) {
-                        if ( isCharType( at->base ) ) {
-                                // check if the resolved type is char*
-                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
-                                        if ( isCharType( pt->base ) ) {
-                                                // strip cast if we're initializing a char[] with a char* 
-                                                // e.g. char x[] = "hello"
-                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
-                                                        swap_and_save_env( newExpr, ce->arg );
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                // move cursor to next object in preparation for next initializer
-                currentObject.increment();
-
-                // set initializer expression to resolved expression
-                return ast::mutate_field( singleInit, &ast::SingleInit::value, std::move(newExpr) );
-        }
-
-        const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
-                // move cursor into brace-enclosed initializer-list
-                currentObject.enterListInit( listInit->location );
-
-                assert( listInit->designations.size() == listInit->initializers.size() );
-                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current 
-                        // designated object and resolving the initializer against that object
-                        #warning unimplemented; Resolver port in progress
-                        assert(false);
-                }
-
-                visit_children = false;
-                return listInit;
+        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)singleInit;
+                assert(false);
+        }
+
+        void Resolver_new::previsit( const ast::ListInit * listInit ) {
+                #warning unimplemented; Resolver port in progress
+                (void)listInit;
+                assert(false);
         }