Changes in / [fce4e31:302d84c2]


Ignore:
Location:
src
Files:
30 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    rfce4e31 r302d84c2  
    13551355        ast::Node * node = nullptr;
    13561356        /// cache of nodes that might be referenced by readonly<> for de-duplication
    1357         std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
     1357        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
    13581358
    13591359        // Local Utilities:
    … …  
    14221422                to<std::vector>::from( make_labels( std::move( labels ) ) )
    14231423
    1424         static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
     1424        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
    14251425
    14261426        /// returns true and sets `node` if in cache
    1427         bool inCache( const BaseSyntaxNode * old ) {
     1427        bool inCache( BaseSyntaxNode * old ) {
    14281428                auto it = cache.find( old );
    14291429                if ( it == cache.end() ) return false;
    … …  
    14341434        // Now all the visit functions:
    14351435
    1436         virtual void visit( const ObjectDecl * old ) override final {
     1436        virtual void visit( ObjectDecl * old ) override final {
    14371437                auto&& type = GET_ACCEPT_1(type, Type);
    14381438                auto&& init = GET_ACCEPT_1(init, Init);
    … …  
    14651465        }
    14661466
    1467         virtual void visit( const FunctionDecl * old ) override final {
     1467        virtual void visit( FunctionDecl * old ) override final {
    14681468                if ( inCache( old ) ) return;
    14691469                auto decl = new ast::FunctionDecl{
    … …  
    14981498        }
    14991499
    1500         virtual void visit( const StructDecl * old ) override final {
     1500        virtual void visit( StructDecl * old ) override final {
    15011501                if ( inCache( old ) ) return;
    15021502                auto decl = new ast::StructDecl(
    … …  
    15231523        }
    15241524
    1525         virtual void visit( const UnionDecl * old ) override final {
     1525        virtual void visit( UnionDecl * old ) override final {
    15261526                if ( inCache( old ) ) return;
    15271527                auto decl = new ast::UnionDecl(
    … …  
    15431543        }
    15441544
    1545         virtual void visit( const EnumDecl * old ) override final {
     1545        virtual void visit( EnumDecl * old ) override final {
    15461546                if ( inCache( old ) ) return;
    15471547                auto decl = new ast::EnumDecl(
    … …  
    15631563        }
    15641564
    1565         virtual void visit( const TraitDecl * old ) override final {
     1565        virtual void visit( TraitDecl * old ) override final {
    15661566                if ( inCache( old ) ) return;
    15671567                auto decl = new ast::TraitDecl(
    … …  
    15831583        }
    15841584
    1585         virtual void visit( const TypeDecl * old ) override final {
     1585        virtual void visit( TypeDecl * old ) override final {
    15861586                if ( inCache( old ) ) return;
    15871587                auto decl = new ast::TypeDecl{
    … …  
    16031603        }
    16041604
    1605         virtual void visit( const TypedefDecl * old ) override final {
     1605        virtual void visit( TypedefDecl * old ) override final {
    16061606                auto decl = new ast::TypedefDecl(
    16071607                        old->location,
    … …  
    16201620        }
    16211621
    1622         virtual void visit( const AsmDecl * old ) override final {
     1622        virtual void visit( AsmDecl * old ) override final {
    16231623                auto decl = new ast::AsmDecl{
    16241624                        old->location,
    … …  
    16321632        }
    16331633
    1634         virtual void visit( const StaticAssertDecl * old ) override final {
     1634        virtual void visit( StaticAssertDecl * old ) override final {
    16351635                auto decl = new ast::StaticAssertDecl{
    16361636                        old->location,
    … …  
    16451645        }
    16461646
    1647         virtual void visit( const CompoundStmt * old ) override final {
     1647        virtual void visit( CompoundStmt * old ) override final {
    16481648                if ( inCache( old ) ) return;
    16491649                auto stmt = new ast::CompoundStmt(
    … …  
    16571657        }
    16581658
    1659         virtual void visit( const ExprStmt * old ) override final {
     1659        virtual void visit( ExprStmt * old ) override final {
    16601660                if ( inCache( old ) ) return;
    16611661                this->node = new ast::ExprStmt(
    … …  
    16671667        }
    16681668
    1669         virtual void visit( const AsmStmt * old ) override final {
     1669        virtual void visit( AsmStmt * old ) override final {
    16701670                if ( inCache( old ) ) return;
    16711671                this->node = new ast::AsmStmt(
    … …  
    16821682        }
    16831683
    1684         virtual void visit( const DirectiveStmt * old ) override final {
     1684        virtual void visit( DirectiveStmt * old ) override final {
    16851685                if ( inCache( old ) ) return;
    16861686                this->node = new ast::DirectiveStmt(
    … …  
    16921692        }
    16931693
    1694         virtual void visit( const IfStmt * old ) override final {
     1694        virtual void visit( IfStmt * old ) override final {
    16951695                if ( inCache( old ) ) return;
    16961696                this->node = new ast::IfStmt(
    … …  
    17051705        }
    17061706
    1707         virtual void visit( const SwitchStmt * old ) override final {
     1707        virtual void visit( SwitchStmt * old ) override final {
    17081708                if ( inCache( old ) ) return;
    17091709                this->node = new ast::SwitchStmt(
    … …  
    17161716        }
    17171717
    1718         virtual void visit( const CaseStmt * old ) override final {
     1718        virtual void visit( CaseStmt * old ) override final {
    17191719                if ( inCache( old ) ) return;
    17201720                this->node = new ast::CaseStmt(
    … …  
    17271727        }
    17281728
    1729         virtual void visit( const WhileStmt * old ) override final {
     1729        virtual void visit( WhileStmt * old ) override final {
    17301730                if ( inCache( old ) ) return;
    17311731                this->node = new ast::WhileStmt(
    … …  
    17401740        }
    17411741
    1742         virtual void visit( const ForStmt * old ) override final {
     1742        virtual void visit( ForStmt * old ) override final {
    17431743                if ( inCache( old ) ) return;
    17441744                this->node = new ast::ForStmt(
    … …  
    17531753        }
    17541754
    1755         virtual void visit( const BranchStmt * old ) override final {
     1755        virtual void visit( BranchStmt * old ) override final {
    17561756                if ( inCache( old ) ) return;
    17571757                if (old->computedTarget) {
    … …  
    17901790        }
    17911791
    1792         virtual void visit( const ReturnStmt * old ) override final {
     1792        virtual void visit( ReturnStmt * old ) override final {
    17931793                if ( inCache( old ) ) return;
    17941794                this->node = new ast::ReturnStmt(
    … …  
    18001800        }
    18011801
    1802         virtual void visit( const ThrowStmt * old ) override final {
     1802        virtual void visit( ThrowStmt * old ) override final {
    18031803                if ( inCache( old ) ) return;
    18041804                ast::ExceptionKind kind;
    … …  
    18241824        }
    18251825
    1826         virtual void visit( const TryStmt * old ) override final {
     1826        virtual void visit( TryStmt * old ) override final {
    18271827                if ( inCache( old ) ) return;
    18281828                this->node = new ast::TryStmt(
    … …  
    18361836        }
    18371837
    1838         virtual void visit( const CatchStmt * old ) override final {
     1838        virtual void visit( CatchStmt * old ) override final {
    18391839                if ( inCache( old ) ) return;
    18401840                ast::ExceptionKind kind;
    … …  
    18611861        }
    18621862
    1863         virtual void visit( const FinallyStmt * old ) override final {
     1863        virtual void visit( FinallyStmt * old ) override final {
    18641864                if ( inCache( old ) ) return;
    18651865                this->node = new ast::FinallyStmt(
    … …  
    18711871        }
    18721872
    1873         virtual void visit( const WaitForStmt * old ) override final {
     1873        virtual void visit( WaitForStmt * old ) override final {
    18741874                if ( inCache( old ) ) return;
    18751875                ast::WaitForStmt * stmt = new ast::WaitForStmt(
    … …  
    19031903        }
    19041904
    1905         virtual void visit( const WithStmt * old ) override final {
     1905        virtual void visit( WithStmt * old ) override final {
    19061906                if ( inCache( old ) ) return;
    19071907                this->node = new ast::WithStmt(
    … …  
    19141914        }
    19151915
    1916         virtual void visit( const NullStmt * old ) override final {
     1916        virtual void visit( NullStmt * old ) override final {
    19171917                if ( inCache( old ) ) return;
    19181918                this->node = new ast::NullStmt(
    … …  
    19231923        }
    19241924
    1925         virtual void visit( const DeclStmt * old ) override final {
     1925        virtual void visit( DeclStmt * old ) override final {
    19261926                if ( inCache( old ) ) return;
    19271927                this->node = new ast::DeclStmt(
    … …  
    19331933        }
    19341934
    1935         virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
     1935        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
    19361936                if ( inCache( old ) ) return;
    19371937                auto stmt = new ast::ImplicitCtorDtorStmt(
    … …  
    19901990        }
    19911991
    1992         ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
     1992        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
    19931993
    19941994                nw->env    = convertTypeSubstitution(old->env);
    … …  
    20002000        }
    20012001
    2002         ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
     2002        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
    20032003
    20042004                nw->result = GET_ACCEPT_1(result, Type);
    … …  
    20062006        }
    20072007
    2008         virtual void visit( const ApplicationExpr * old ) override final {
     2008        virtual void visit( ApplicationExpr * old ) override final {
    20092009                this->node = visitBaseExpr( old,
    20102010                        new ast::ApplicationExpr(
    … …  
    20162016        }
    20172017
    2018         virtual void visit( const UntypedExpr * old ) override final {
     2018        virtual void visit( UntypedExpr * old ) override final {
    20192019                this->node = visitBaseExpr( old,
    20202020                        new ast::UntypedExpr(
    … …  
    20262026        }
    20272027
    2028         virtual void visit( const NameExpr * old ) override final {
     2028        virtual void visit( NameExpr * old ) override final {
    20292029                this->node = visitBaseExpr( old,
    20302030                        new ast::NameExpr(
    … …  
    20352035        }
    20362036
    2037         virtual void visit( const CastExpr * old ) override final {
     2037        virtual void visit( CastExpr * old ) override final {
    20382038                this->node = visitBaseExpr( old,
    20392039                        new ast::CastExpr(
    … …  
    20452045        }
    20462046
    2047         virtual void visit( const KeywordCastExpr * old) override final {
     2047        virtual void visit( KeywordCastExpr * old) override final {
    20482048                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
    20492049                switch (old->target) {
    … …  
    20702070        }
    20712071
    2072         virtual void visit( const VirtualCastExpr * old ) override final {
     2072        virtual void visit( VirtualCastExpr * old ) override final {
    20732073                this->node = visitBaseExpr_SkipResultType( old,
    20742074                        new ast::VirtualCastExpr(
    … …  
    20802080        }
    20812081
    2082         virtual void visit( const AddressExpr * old ) override final {
     2082        virtual void visit( AddressExpr * old ) override final {
    20832083                this->node = visitBaseExpr( old,
    20842084                        new ast::AddressExpr(
    … …  
    20892089        }
    20902090
    2091         virtual void visit( const LabelAddressExpr * old ) override final {
     2091        virtual void visit( LabelAddressExpr * old ) override final {
    20922092                this->node = visitBaseExpr( old,
    20932093                        new ast::LabelAddressExpr(
    … …  
    20982098        }
    20992099
    2100         virtual void visit( const UntypedMemberExpr * old ) override final {
     2100        virtual void visit( UntypedMemberExpr * old ) override final {
    21012101                this->node = visitBaseExpr( old,
    21022102                        new ast::UntypedMemberExpr(
    … …  
    21082108        }
    21092109
    2110         virtual void visit( const MemberExpr * old ) override final {
     2110        virtual void visit( MemberExpr * old ) override final {
    21112111                this->node = visitBaseExpr( old,
    21122112                        new ast::MemberExpr(
    … …  
    21182118        }
    21192119
    2120         virtual void visit( const VariableExpr * old ) override final {
     2120        virtual void visit( VariableExpr * old ) override final {
    21212121                auto expr = new ast::VariableExpr(
    21222122                        old->location
    … …  
    21292129        }
    21302130
    2131         virtual void visit( const ConstantExpr * old ) override final {
     2131        virtual void visit( ConstantExpr * old ) override final {
    21322132                ast::ConstantExpr *rslt = new ast::ConstantExpr(
    21332133                        old->location,
    21342134                        GET_ACCEPT_1(result, Type),
    2135                         old->constant.rep,
     2135                        old->constant.get_value(),
    21362136                        old->constant.ival
    21372137                );
    2138                 rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
     2138                rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.get_type() );
    21392139                this->node = visitBaseExpr( old, rslt );
    21402140        }
    21412141
    2142         virtual void visit( const SizeofExpr * old ) override final {
     2142        virtual void visit( SizeofExpr * old ) override final {
    21432143                assert (old->expr || old->type);
    21442144                assert (! (old->expr && old->type));
    … …  
    21612161        }
    21622162
    2163         virtual void visit( const AlignofExpr * old ) override final {
     2163        virtual void visit( AlignofExpr * old ) override final {
    21642164                assert (old->expr || old->type);
    21652165                assert (! (old->expr && old->type));
    … …  
    21822182        }
    21832183
    2184         virtual void visit( const UntypedOffsetofExpr * old ) override final {
     2184        virtual void visit( UntypedOffsetofExpr * old ) override final {
    21852185                this->node = visitBaseExpr( old,
    21862186                        new ast::UntypedOffsetofExpr(
    … …  
    21922192        }
    21932193
    2194         virtual void visit( const OffsetofExpr * old ) override final {
     2194        virtual void visit( OffsetofExpr * old ) override final {
    21952195                this->node = visitBaseExpr( old,
    21962196                        new ast::OffsetofExpr(
    … …  
    22022202        }
    22032203
    2204         virtual void visit( const OffsetPackExpr * old ) override final {
     2204        virtual void visit( OffsetPackExpr * old ) override final {
    22052205                this->node = visitBaseExpr( old,
    22062206                        new ast::OffsetPackExpr(
    … …  
    22112211        }
    22122212
    2213         virtual void visit( const LogicalExpr * old ) override final {
     2213        virtual void visit( LogicalExpr * old ) override final {
    22142214                this->node = visitBaseExpr( old,
    22152215                        new ast::LogicalExpr(
    … …  
    22242224        }
    22252225
    2226         virtual void visit( const ConditionalExpr * old ) override final {
     2226        virtual void visit( ConditionalExpr * old ) override final {
    22272227                this->node = visitBaseExpr( old,
    22282228                        new ast::ConditionalExpr(
    … …  
    22352235        }
    22362236
    2237         virtual void visit( const CommaExpr * old ) override final {
     2237        virtual void visit( CommaExpr * old ) override final {
    22382238                this->node = visitBaseExpr( old,
    22392239                        new ast::CommaExpr(
    … …  
    22452245        }
    22462246
    2247         virtual void visit( const TypeExpr * old ) override final {
     2247        virtual void visit( TypeExpr * old ) override final {
    22482248                this->node = visitBaseExpr( old,
    22492249                        new ast::TypeExpr(
    … …  
    22542254        }
    22552255
    2256         virtual void visit( const AsmExpr * old ) override final {
     2256        virtual void visit( AsmExpr * old ) override final {
    22572257                this->node = visitBaseExpr( old,
    22582258                        new ast::AsmExpr(
    … …  
    22652265        }
    22662266
    2267         virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
     2267        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
    22682268                auto rslt = new ast::ImplicitCopyCtorExpr(
    22692269                        old->location,
    … …  
    22742274        }
    22752275
    2276         virtual void visit( const ConstructorExpr * old ) override final {
     2276        virtual void visit( ConstructorExpr * old ) override final {
    22772277                this->node = visitBaseExpr( old,
    22782278                        new ast::ConstructorExpr(
    … …  
    22832283        }
    22842284
    2285         virtual void visit( const CompoundLiteralExpr * old ) override final {
     2285        virtual void visit( CompoundLiteralExpr * old ) override final {
    22862286                this->node = visitBaseExpr_SkipResultType( old,
    22872287                        new ast::CompoundLiteralExpr(
    … …  
    22932293        }
    22942294
    2295         virtual void visit( const RangeExpr * old ) override final {
     2295        virtual void visit( RangeExpr * old ) override final {
    22962296                this->node = visitBaseExpr( old,
    22972297                        new ast::RangeExpr(
    … …  
    23032303        }
    23042304
    2305         virtual void visit( const UntypedTupleExpr * old ) override final {
     2305        virtual void visit( UntypedTupleExpr * old ) override final {
    23062306                this->node = visitBaseExpr( old,
    23072307                        new ast::UntypedTupleExpr(
    … …  
    23122312        }
    23132313
    2314         virtual void visit( const TupleExpr * old ) override final {
     2314        virtual void visit( TupleExpr * old ) override final {
    23152315                this->node = visitBaseExpr( old,
    23162316                        new ast::TupleExpr(
    … …  
    23212321        }
    23222322
    2323         virtual void visit( const TupleIndexExpr * old ) override final {
     2323        virtual void visit( TupleIndexExpr * old ) override final {
    23242324                this->node = visitBaseExpr( old,
    23252325                        new ast::TupleIndexExpr(
    … …  
    23312331        }
    23322332
    2333         virtual void visit( const TupleAssignExpr * old ) override final {
     2333        virtual void visit( TupleAssignExpr * old ) override final {
    23342334                this->node = visitBaseExpr_SkipResultType( old,
    23352335                        new ast::TupleAssignExpr(
    … …  
    23412341        }
    23422342
    2343         virtual void visit( const StmtExpr * old ) override final {
     2343        virtual void visit( StmtExpr * old ) override final {
    23442344                auto rslt = new ast::StmtExpr(
    23452345                        old->location,
    … …  
    23522352        }
    23532353
    2354         virtual void visit( const UniqueExpr * old ) override final {
     2354        virtual void visit( UniqueExpr * old ) override final {
    23552355                auto rslt = new ast::UniqueExpr(
    23562356                        old->location,
    … …  
    23642364        }
    23652365
    2366         virtual void visit( const UntypedInitExpr * old ) override final {
     2366        virtual void visit( UntypedInitExpr * old ) override final {
    23672367                std::deque<ast::InitAlternative> initAlts;
    23682368                for (auto ia : old->initAlts) {
    … …  
    23812381        }
    23822382
    2383         virtual void visit( const InitExpr * old ) override final {
     2383        virtual void visit( InitExpr * old ) override final {
    23842384                this->node = visitBaseExpr( old,
    23852385                        new ast::InitExpr(
    … …  
    23912391        }
    23922392
    2393         virtual void visit( const DeletedExpr * old ) override final {
     2393        virtual void visit( DeletedExpr * old ) override final {
    23942394                this->node = visitBaseExpr( old,
    23952395                        new ast::DeletedExpr(
    … …  
    24032403        }
    24042404
    2405         virtual void visit( const DefaultArgExpr * old ) override final {
     2405        virtual void visit( DefaultArgExpr * old ) override final {
    24062406                this->node = visitBaseExpr( old,
    24072407                        new ast::DefaultArgExpr(
    … …  
    24122412        }
    24132413
    2414         virtual void visit( const GenericExpr * old ) override final {
     2414        virtual void visit( GenericExpr * old ) override final {
    24152415                std::vector<ast::GenericExpr::Association> associations;
    24162416                for (auto association : old->associations) {
    … …  
    24292429        }
    24302430
    2431         void visitType( const Type * old, ast::Type * type ) {
     2431        void visitType( Type * old, ast::Type * type ) {
    24322432                // Some types do this in their constructor so add a check.
    24332433                if ( !old->attributes.empty() && type->attributes.empty() ) {
    … …  
    24372437        }
    24382438
    2439         virtual void visit( const VoidType * old ) override final {
     2439        virtual void visit( VoidType * old ) override final {
    24402440                visitType( old, new ast::VoidType{ cv( old ) } );
    24412441        }
    24422442
    2443         virtual void visit( const BasicType * old ) override final {
     2443        virtual void visit( BasicType * old ) override final {
    24442444                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
    24452445                // I believe this should always be a BasicType.
    … …  
    24502450        }
    24512451
    2452         virtual void visit( const PointerType * old ) override final {
     2452        virtual void visit( PointerType * old ) override final {
    24532453                visitType( old, new ast::PointerType{
    24542454                        GET_ACCEPT_1( base, Type ),
    … …  
    24602460        }
    24612461
    2462         virtual void visit( const ArrayType * old ) override final {
     2462        virtual void visit( ArrayType * old ) override final {
    24632463                visitType( old, new ast::ArrayType{
    24642464                        GET_ACCEPT_1( base, Type ),
    … …  
    24702470        }
    24712471
    2472         virtual void visit( const ReferenceType * old ) override final {
     2472        virtual void visit( ReferenceType * old ) override final {
    24732473                visitType( old, new ast::ReferenceType{
    24742474                        GET_ACCEPT_1( base, Type ),
    … …  
    24772477        }
    24782478
    2479         virtual void visit( const QualifiedType * old ) override final {
     2479        virtual void visit( QualifiedType * old ) override final {
    24802480                visitType( old, new ast::QualifiedType{
    24812481                        GET_ACCEPT_1( parent, Type ),
    … …  
    24852485        }
    24862486
    2487         virtual void visit( const FunctionType * old ) override final {
     2487        virtual void visit( FunctionType * old ) override final {
    24882488                auto ty = new ast::FunctionType {
    24892489                        (ast::ArgumentFlag)old->isVarArgs,
    … …  
    24962496        }
    24972497
    2498         void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
     2498        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
    24992499                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25002500                ty->params = GET_ACCEPT_V( parameters, Expr );
    … …  
    25032503        }
    25042504
    2505         virtual void visit( const StructInstType * old ) override final {
     2505        virtual void visit( StructInstType * old ) override final {
    25062506                ast::StructInstType * ty;
    25072507                if ( old->baseStruct ) {
    … …  
    25212521        }
    25222522
    2523         virtual void visit( const UnionInstType * old ) override final {
     2523        virtual void visit( UnionInstType * old ) override final {
    25242524                ast::UnionInstType * ty;
    25252525                if ( old->baseUnion ) {
    … …  
    25392539        }
    25402540
    2541         virtual void visit( const EnumInstType * old ) override final {
     2541        virtual void visit( EnumInstType * old ) override final {
    25422542                ast::EnumInstType * ty;
    25432543                if ( old->baseEnum ) {
    … …  
    25572557        }
    25582558
    2559         virtual void visit( const TraitInstType * old ) override final {
     2559        virtual void visit( TraitInstType * old ) override final {
    25602560                ast::TraitInstType * ty;
    25612561                if ( old->baseTrait ) {
    … …  
    25752575        }
    25762576
    2577         virtual void visit( const TypeInstType * old ) override final {
     2577        virtual void visit( TypeInstType * old ) override final {
    25782578                ast::TypeInstType * ty;
    25792579                if ( old->baseType ) {
    … …  
    25952595        }
    25962596
    2597         virtual void visit( const TupleType * old ) override final {
     2597        virtual void visit( TupleType * old ) override final {
    25982598                visitType( old, new ast::TupleType{
    25992599                        GET_ACCEPT_V( types, Type ),
    … …  
    26032603        }
    26042604
    2605         virtual void visit( const TypeofType * old ) override final {
     2605        virtual void visit( TypeofType * old ) override final {
    26062606                visitType( old, new ast::TypeofType{
    26072607                        GET_ACCEPT_1( expr, Expr ),
    … …  
    26112611        }
    26122612
    2613         virtual void visit( const AttrType * ) override final {
     2613        virtual void visit( AttrType * ) override final {
    26142614                assertf( false, "AttrType deprecated in new AST." );
    26152615        }
    26162616
    2617         virtual void visit( const VarArgsType * old ) override final {
     2617        virtual void visit( VarArgsType * old ) override final {
    26182618                visitType( old, new ast::VarArgsType{ cv( old ) } );
    26192619        }
    26202620
    2621         virtual void visit( const ZeroType * old ) override final {
     2621        virtual void visit( ZeroType * old ) override final {
    26222622                visitType( old, new ast::ZeroType{ cv( old ) } );
    26232623        }
    26242624
    2625         virtual void visit( const OneType * old ) override final {
     2625        virtual void visit( OneType * old ) override final {
    26262626                visitType( old, new ast::OneType{ cv( old ) } );
    26272627        }
    26282628
    2629         virtual void visit( const GlobalScopeType * old ) override final {
     2629        virtual void visit( GlobalScopeType * old ) override final {
    26302630                visitType( old, new ast::GlobalScopeType{} );
    26312631        }
    26322632
    2633         virtual void visit( const Designation * old ) override final {
     2633        virtual void visit( Designation * old ) override final {
    26342634                this->node = new ast::Designation(
    26352635                        old->location,
    … …  
    26382638        }
    26392639
    2640         virtual void visit( const SingleInit * old ) override final {
     2640        virtual void visit( SingleInit * old ) override final {
    26412641                this->node = new ast::SingleInit(
    26422642                        old->location,
    … …  
    26462646        }
    26472647
    2648         virtual void visit( const ListInit * old ) override final {
     2648        virtual void visit( ListInit * old ) override final {
    26492649                this->node = new ast::ListInit(
    26502650                        old->location,
    … …  
    26552655        }
    26562656
    2657         virtual void visit( const ConstructorInit * old ) override final {
     2657        virtual void visit( ConstructorInit * old ) override final {
    26582658                this->node = new ast::ConstructorInit(
    26592659                        old->location,
    … …  
    26642664        }
    26652665
    2666         virtual void visit( const Constant * ) override final {
     2666        virtual void visit( Constant * ) override final {
    26672667                // Handled in visit( ConstantEpxr * ).
    26682668                // In the new tree, Constant fields are inlined into containing ConstantExpression.
    … …  
    26702670        }
    26712671
    2672         virtual void visit( const Attribute * old ) override final {
     2672        virtual void visit( Attribute * old ) override final {
    26732673                this->node = new ast::Attribute(
    26742674                        old->name,
    … …  
    26772677        }
    26782678
    2679         virtual void visit( const AttrExpr * ) override final {
     2679        virtual void visit( AttrExpr * ) override final {
    26802680                assertf( false, "AttrExpr deprecated in new AST." );
    26812681        }

  • src/AST/Expr.hpp

    rfce4e31 r302d84c2  
    4747
    4848        ParamEntry() : decl( 0 ), declptr( nullptr ), actualType( nullptr ), formalType( nullptr ), expr( nullptr ) {}
    49         ParamEntry(
    50                 UniqueId id, const Decl * declptr, const Type * actual, const Type * formal,
     49        ParamEntry( 
     50                UniqueId id, const Decl * declptr, const Type * actual, const Type * formal, 
    5151                const Expr * e )
    5252        : decl( id ), declptr( declptr ), actualType( actual ), formalType( formal ), expr( e ) {}
    … …  
    112112                        case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough
    113113                        case Slots: return data.resnSlots;
    114                         case Params: assertf(false, "Cannot return to resnSlots from Params"); abort();
     114                        case Params: assert(!"Cannot return to resnSlots from Params");
    115115                        }
     116                        return *((ResnSlots*)nullptr);
    116117                }
    117118
    … …  
    120121                                return data.resnSlots;
    121122                        }
    122                         assertf(false, "Mode was not already resnSlots");
    123                         abort();
     123                        assert(!"Mode was not already resnSlots");
     124                        return *((ResnSlots*)nullptr);
    124125                }
    125126
    … …  
    130131                        case Params: return data.inferParams;
    131132                        }
    132                         assertf(false, "unreachable");
     133                        assert(!"unreachable");
     134                        return *((InferredParams*)nullptr);
    133135                }
    134136
    … …  
    137139                                return data.inferParams;
    138140                        }
    139                         assertf(false, "Mode was not already Params");
    140                         abort();
     141                        assert(!"Mode was not already Params");
     142                        return *((InferredParams*)nullptr);
    141143                }
    142144
    143145                void set_inferParams( InferredParams && ps ) {
    144146                        switch(mode) {
    145                         case Slots:
     147                        case Slots: 
    146148                                data.resnSlots.~ResnSlots();
    147149                                // fallthrough
    148                         case Empty:
     150                        case Empty: 
    149151                                new(&data.inferParams) InferredParams{ std::move( ps ) };
    150152                                mode = Params;
    … …  
    170172                                        data.inferParams[p.first] = std::move(p.second);
    171173                                }
    172                         } else assertf(false, "invalid mode");
     174                        } else assert(!"invalid mode");
    173175                }
    174176        };
    … …  
    382384
    383385        ConstantExpr(
    384                 const CodeLocation & loc, const Type * ty, const std::string & r,
     386                const CodeLocation & loc, const Type * ty, const std::string & r, 
    385387                        std::optional<unsigned long long> i )
    386388        : Expr( loc, ty ), rep( r ), ival( i ) {}

  • src/Common/PassVisitor.h

    rfce4e31 r302d84c2  
    6060
    6161        virtual void visit( ObjectDecl * objectDecl ) override final;
    62         virtual void visit( const ObjectDecl * objectDecl ) override final;
    6362        virtual void visit( FunctionDecl * functionDecl ) override final;
    64         virtual void visit( const FunctionDecl * functionDecl ) override final;
    6563        virtual void visit( StructDecl * aggregateDecl ) override final;
    66         virtual void visit( const StructDecl * aggregateDecl ) override final;
    6764        virtual void visit( UnionDecl * aggregateDecl ) override final;
    68         virtual void visit( const UnionDecl * aggregateDecl ) override final;
    6965        virtual void visit( EnumDecl * aggregateDecl ) override final;
    70         virtual void visit( const EnumDecl * aggregateDecl ) override final;
    7166        virtual void visit( TraitDecl * aggregateDecl ) override final;
    72         virtual void visit( const TraitDecl * aggregateDecl ) override final;
    7367        virtual void visit( TypeDecl * typeDecl ) override final;
    74         virtual void visit( const TypeDecl * typeDecl ) override final;
    7568        virtual void visit( TypedefDecl * typeDecl ) override final;
    76         virtual void visit( const TypedefDecl * typeDecl ) override final;
    7769        virtual void visit( AsmDecl * asmDecl ) override final;
    78         virtual void visit( const AsmDecl * asmDecl ) override final;
    7970        virtual void visit( StaticAssertDecl * assertDecl ) override final;
    80         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
    8171
    8272        virtual void visit( CompoundStmt * compoundStmt ) override final;
    83         virtual void visit( const CompoundStmt * compoundStmt ) override final;
    8473        virtual void visit( ExprStmt * exprStmt ) override final;
    85         virtual void visit( const ExprStmt * exprStmt ) override final;
    8674        virtual void visit( AsmStmt * asmStmt ) override final;
    87         virtual void visit( const AsmStmt * asmStmt ) override final;
    8875        virtual void visit( DirectiveStmt * dirStmt ) override final;
    89         virtual void visit( const DirectiveStmt * dirStmt ) override final;
    9076        virtual void visit( IfStmt * ifStmt ) override final;
    91         virtual void visit( const IfStmt * ifStmt ) override final;
    9277        virtual void visit( WhileStmt * whileStmt ) override final;
    93         virtual void visit( const WhileStmt * whileStmt ) override final;
    9478        virtual void visit( ForStmt * forStmt ) override final;
    95         virtual void visit( const ForStmt * forStmt ) override final;
    9679        virtual void visit( SwitchStmt * switchStmt ) override final;
    97         virtual void visit( const SwitchStmt * switchStmt ) override final;
    9880        virtual void visit( CaseStmt * caseStmt ) override final;
    99         virtual void visit( const CaseStmt * caseStmt ) override final;
    10081        virtual void visit( BranchStmt * branchStmt ) override final;
    101         virtual void visit( const BranchStmt * branchStmt ) override final;
    10282        virtual void visit( ReturnStmt * returnStmt ) override final;
    103         virtual void visit( const ReturnStmt * returnStmt ) override final;
    10483        virtual void visit( ThrowStmt * throwStmt ) override final;
    105         virtual void visit( const ThrowStmt * throwStmt ) override final;
    10684        virtual void visit( TryStmt * tryStmt ) override final;
    107         virtual void visit( const TryStmt * tryStmt ) override final;
    10885        virtual void visit( CatchStmt * catchStmt ) override final;
    109         virtual void visit( const CatchStmt * catchStmt ) override final;
    11086        virtual void visit( FinallyStmt * finallyStmt ) override final;
    111         virtual void visit( const FinallyStmt * finallyStmt ) override final;
    11287        virtual void visit( WaitForStmt * waitforStmt ) override final;
    113         virtual void visit( const WaitForStmt * waitforStmt ) override final;
    11488        virtual void visit( WithStmt * withStmt ) override final;
    115         virtual void visit( const WithStmt * withStmt ) override final;
    11689        virtual void visit( NullStmt * nullStmt ) override final;
    117         virtual void visit( const NullStmt * nullStmt ) override final;
    11890        virtual void visit( DeclStmt * declStmt ) override final;
    119         virtual void visit( const DeclStmt * declStmt ) override final;
    12091        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
    121         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
    12292
    12393        virtual void visit( ApplicationExpr * applicationExpr ) override final;
    124         virtual void visit( const ApplicationExpr * applicationExpr ) override final;
    12594        virtual void visit( UntypedExpr * untypedExpr ) override final;
    126         virtual void visit( const UntypedExpr * untypedExpr ) override final;
    12795        virtual void visit( NameExpr * nameExpr ) override final;
    128         virtual void visit( const NameExpr * nameExpr ) override final;
    12996        virtual void visit( CastExpr * castExpr ) override final;
    130         virtual void visit( const CastExpr * castExpr ) override final;
    13197        virtual void visit( KeywordCastExpr * castExpr ) override final;
    132         virtual void visit( const KeywordCastExpr * castExpr ) override final;
    13398        virtual void visit( VirtualCastExpr * castExpr ) override final;
    134         virtual void visit( const VirtualCastExpr * castExpr ) override final;
    13599        virtual void visit( AddressExpr * addressExpr ) override final;
    136         virtual void visit( const AddressExpr * addressExpr ) override final;
    137100        virtual void visit( LabelAddressExpr * labAddressExpr ) override final;
    138         virtual void visit( const LabelAddressExpr * labAddressExpr ) override final;
    139101        virtual void visit( UntypedMemberExpr * memberExpr ) override final;
    140         virtual void visit( const UntypedMemberExpr * memberExpr ) override final;
    141102        virtual void visit( MemberExpr * memberExpr ) override final;
    142         virtual void visit( const MemberExpr * memberExpr ) override final;
    143103        virtual void visit( VariableExpr * variableExpr ) override final;
    144         virtual void visit( const VariableExpr * variableExpr ) override final;
    145104        virtual void visit( ConstantExpr * constantExpr ) override final;
    146         virtual void visit( const ConstantExpr * constantExpr ) override final;
    147105        virtual void visit( SizeofExpr * sizeofExpr ) override final;
    148         virtual void visit( const SizeofExpr * sizeofExpr ) override final;
    149106        virtual void visit( AlignofExpr * alignofExpr ) override final;
    150         virtual void visit( const AlignofExpr * alignofExpr ) override final;
    151107        virtual void visit( UntypedOffsetofExpr * offsetofExpr ) override final;
    152         virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) override final;
    153108        virtual void visit( OffsetofExpr * offsetofExpr ) override final;
    154         virtual void visit( const OffsetofExpr * offsetofExpr ) override final;
    155109        virtual void visit( OffsetPackExpr * offsetPackExpr ) override final;
    156         virtual void visit( const OffsetPackExpr * offsetPackExpr ) override final;
    157110        virtual void visit( AttrExpr * attrExpr ) override final;
    158         virtual void visit( const AttrExpr * attrExpr ) override final;
    159111        virtual void visit( LogicalExpr * logicalExpr ) override final;
    160         virtual void visit( const LogicalExpr * logicalExpr ) override final;
    161112        virtual void visit( ConditionalExpr * conditionalExpr ) override final;
    162         virtual void visit( const ConditionalExpr * conditionalExpr ) override final;
    163113        virtual void visit( CommaExpr * commaExpr ) override final;
    164         virtual void visit( const CommaExpr * commaExpr ) override final;
    165114        virtual void visit( TypeExpr * typeExpr ) override final;
    166         virtual void visit( const TypeExpr * typeExpr ) override final;
    167115        virtual void visit( AsmExpr * asmExpr ) override final;
    168         virtual void visit( const AsmExpr * asmExpr ) override final;
    169116        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
    170         virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
    171117        virtual void visit( ConstructorExpr *  ctorExpr ) override final;
    172         virtual void visit( const ConstructorExpr *  ctorExpr ) override final;
    173118        virtual void visit( CompoundLiteralExpr * compLitExpr ) override final;
    174         virtual void visit( const CompoundLiteralExpr * compLitExpr ) override final;
    175119        virtual void visit( RangeExpr * rangeExpr ) override final;
    176         virtual void visit( const RangeExpr * rangeExpr ) override final;
    177120        virtual void visit( UntypedTupleExpr * tupleExpr ) override final;
    178         virtual void visit( const UntypedTupleExpr * tupleExpr ) override final;
    179121        virtual void visit( TupleExpr * tupleExpr ) override final;
    180         virtual void visit( const TupleExpr * tupleExpr ) override final;
    181122        virtual void visit( TupleIndexExpr * tupleExpr ) override final;
    182         virtual void visit( const TupleIndexExpr * tupleExpr ) override final;
    183123        virtual void visit( TupleAssignExpr * assignExpr ) override final;
    184         virtual void visit( const TupleAssignExpr * assignExpr ) override final;
    185124        virtual void visit( StmtExpr *  stmtExpr ) override final;
    186         virtual void visit( const StmtExpr *  stmtExpr ) override final;
    187125        virtual void visit( UniqueExpr *  uniqueExpr ) override final;
    188         virtual void visit( const UniqueExpr *  uniqueExpr ) override final;
    189126        virtual void visit( UntypedInitExpr *  initExpr ) override final;
    190         virtual void visit( const UntypedInitExpr *  initExpr ) override final;
    191127        virtual void visit( InitExpr *  initExpr ) override final;
    192         virtual void visit( const InitExpr *  initExpr ) override final;
    193128        virtual void visit( DeletedExpr *  delExpr ) override final;
    194         virtual void visit( const DeletedExpr *  delExpr ) override final;
    195129        virtual void visit( DefaultArgExpr * argExpr ) override final;
    196         virtual void visit( const DefaultArgExpr * argExpr ) override final;
    197130        virtual void visit( GenericExpr * genExpr ) override final;
    198         virtual void visit( const GenericExpr * genExpr ) override final;
    199131
    200132        virtual void visit( VoidType * basicType ) override final;
    201         virtual void visit( const VoidType * basicType ) override final;
    202133        virtual void visit( BasicType * basicType ) override final;
    203         virtual void visit( const BasicType * basicType ) override final;
    204134        virtual void visit( PointerType * pointerType ) override final;
    205         virtual void visit( const PointerType * pointerType ) override final;
    206135        virtual void visit( ArrayType * arrayType ) override final;
    207         virtual void visit( const ArrayType * arrayType ) override final;
    208136        virtual void visit( ReferenceType * referenceType ) override final;
    209         virtual void visit( const ReferenceType * referenceType ) override final;
    210137        virtual void visit( QualifiedType * qualType ) override final;
    211         virtual void visit( const QualifiedType * qualType ) override final;
    212138        virtual void visit( FunctionType * functionType ) override final;
    213         virtual void visit( const FunctionType * functionType ) override final;
    214139        virtual void visit( StructInstType * aggregateUseType ) override final;
    215         virtual void visit( const StructInstType * aggregateUseType ) override final;
    216140        virtual void visit( UnionInstType * aggregateUseType ) override final;
    217         virtual void visit( const UnionInstType * aggregateUseType ) override final;
    218141        virtual void visit( EnumInstType * aggregateUseType ) override final;
    219         virtual void visit( const EnumInstType * aggregateUseType ) override final;
    220142        virtual void visit( TraitInstType * aggregateUseType ) override final;
    221         virtual void visit( const TraitInstType * aggregateUseType ) override final;
    222143        virtual void visit( TypeInstType * aggregateUseType ) override final;
    223         virtual void visit( const TypeInstType * aggregateUseType ) override final;
    224144        virtual void visit( TupleType * tupleType ) override final;
    225         virtual void visit( const TupleType * tupleType ) override final;
    226145        virtual void visit( TypeofType * typeofType ) override final;
    227         virtual void visit( const TypeofType * typeofType ) override final;
    228146        virtual void visit( AttrType * attrType ) override final;
    229         virtual void visit( const AttrType * attrType ) override final;
    230147        virtual void visit( VarArgsType * varArgsType ) override final;
    231         virtual void visit( const VarArgsType * varArgsType ) override final;
    232148        virtual void visit( ZeroType * zeroType ) override final;
    233         virtual void visit( const ZeroType * zeroType ) override final;
    234149        virtual void visit( OneType * oneType ) override final;
    235         virtual void visit( const OneType * oneType ) override final;
    236150        virtual void visit( GlobalScopeType * globalType ) override final;
    237         virtual void visit( const GlobalScopeType * globalType ) override final;
    238151
    239152        virtual void visit( Designation * designation ) override final;
    240         virtual void visit( const Designation * designation ) override final;
    241153        virtual void visit( SingleInit * singleInit ) override final;
    242         virtual void visit( const SingleInit * singleInit ) override final;
    243154        virtual void visit( ListInit * listInit ) override final;
    244         virtual void visit( const ListInit * listInit ) override final;
    245155        virtual void visit( ConstructorInit * ctorInit ) override final;
    246         virtual void visit( const ConstructorInit * ctorInit ) override final;
    247156
    248157        virtual void visit( Constant * constant ) override final;
    249         virtual void visit( const Constant * constant ) override final;
    250158
    251159        virtual void visit( Attribute * attribute ) override final;
    252         virtual void visit( const Attribute * attribute ) override final;
    253160
    254161        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final;
    … …  
    358265
    359266        template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
    360         template<typename pass_t> friend void acceptAll( const std::list< const Declaration * > &decls, PassVisitor< pass_t >& visitor );
    361267        template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
    362268        template< typename TreeType, typename pass_t > friend void maybeAccept_impl( TreeType * tree, PassVisitor< pass_t > & visitor );
    363         template< typename TreeType, typename pass_t > friend void maybeAccept_impl( const TreeType * tree, PassVisitor< pass_t > & visitor );
    364269        template< typename TreeType, typename pass_t > friend void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_t > & mutator );
    365270        template< typename Container, typename pass_t > friend void maybeAccept_impl( Container & container, PassVisitor< pass_t > & visitor );
    366         template< typename Container, typename pass_t > friend void maybeAccept_impl( const Container & container, PassVisitor< pass_t > & visitor );
    367271        template< typename Container, typename pass_t > friend void maybeMutate_impl( Container & container, PassVisitor< pass_t > & mutator );
    368272
    369273        template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
    370         template<typename node_type> void call_previsit ( const node_type * node ) { previsit_impl ( pass, node, 0 ); }
    371274        template<typename node_type> void call_postvisit( node_type * node ) { postvisit_impl( pass, node, 0 ); }
    372         template<typename node_type> void call_postvisit( const node_type * node ) { postvisit_impl( pass, node, 0 ); }
    373275
    374276        template<typename node_type> void call_premutate ( node_type * node ) { premutate_impl( pass, node, 0 ); }
    … …  
    384286        void visitStatementList ( std::list< Statement* > &statements );
    385287        void mutateStatementList( std::list< Statement* > &statements );
    386         void visitStatementList ( const std::list< Statement * > & statements );
    387288
    388289        template< typename func_t >
    … …  
    390291        Statement * visitStatement ( Statement * stmt );
    391292        Statement * mutateStatement( Statement * stmt );
    392         void visitStatement ( const Statement * stmt );
    393293
    394294        template< typename func_t >
    … …  
    396296        Expression * visitExpression ( Expression * expr );
    397297        Expression * mutateExpression( Expression * expr );
    398         void visitExpression ( const Expression * expr );
    399298
    400299

  • src/Common/PassVisitor.impl.h

    rfce4e31 r302d84c2  
    8080
    8181template< typename pass_type >
    82 inline void acceptAll( const std::list< const Declaration * > & decls, PassVisitor< pass_type >& visitor ) {
    83         SemanticErrorException errors;
    84 
    85         pass_visitor_stats.depth++;
    86         pass_visitor_stats.max->push(pass_visitor_stats.depth);
    87         pass_visitor_stats.avg->push(pass_visitor_stats.depth);
    88         for ( const Declaration * decl : decls ) {
    89                 try {
    90                         // run visitor on declaration
    91                         maybeAccept_impl( decl, visitor );
    92                 }
    93                 catch( SemanticErrorException &e ) {
    94                         errors.append( e );
    95                 }
    96         }
    97         pass_visitor_stats.depth--;
    98         if ( ! errors.isEmpty() ) {
    99                 throw errors;
    100         }
    101 }
    102 
    103 template< typename pass_type >
    10482inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
    10583        DeclList_t* beforeDecls = mutator.get_beforeDecls();
    … …  
    139117}
    140118
    141 template< typename TreeType, typename pass_type >
    142 inline void maybeAccept_impl( const TreeType * tree, PassVisitor< pass_type > & visitor ) {
    143         if ( ! visitor.get_visit_children() ) return;
    144         if ( tree ) {
    145                 tree->accept( visitor );
    146         }
    147 }
    148 
    149119template< typename Container, typename pass_type >
    150120inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
    … …  
    159129                        if ( *i ) {
    160130                                (*i)->accept( visitor );
    161                         }
    162                 } catch( SemanticErrorException &e ) {
    163                         errors.append( e );
    164                 }
    165         }
    166         pass_visitor_stats.depth--;
    167         if ( ! errors.isEmpty() ) {
    168                 throw errors;
    169         }
    170 }
    171 
    172 template< typename Container, typename pass_type >
    173 inline void maybeAccept_impl( const Container & container, PassVisitor< pass_type > & visitor ) {
    174         if ( ! visitor.get_visit_children() ) return;
    175         SemanticErrorException errors;
    176 
    177         pass_visitor_stats.depth++;
    178         pass_visitor_stats.max->push(pass_visitor_stats.depth);
    179         pass_visitor_stats.avg->push(pass_visitor_stats.depth);
    180         for ( const auto & i : container ) {
    181                 try {
    182                         if ( i ) {
    183                                 i->accept( visitor );
    184131                        }
    185132                } catch( SemanticErrorException &e ) {
    … …  
    280227
    281228template< typename pass_type >
    282 void PassVisitor< pass_type >::visitStatementList( const std::list< Statement * > & statements ) {
    283         if ( ! get_visit_children() ) return;
    284         SemanticErrorException errors;
    285 
    286         pass_visitor_stats.depth++;
    287         pass_visitor_stats.max->push(pass_visitor_stats.depth);
    288         pass_visitor_stats.avg->push(pass_visitor_stats.depth);
    289         for ( const Statement * i : statements ) {
    290                 try {
    291                         maybeAccept_impl( i, *this );
    292                 } catch ( SemanticErrorException &e ) {
    293                         errors.append( e );
    294                 }
    295         }
    296         pass_visitor_stats.depth--;
    297         if ( !errors.isEmpty() ) { throw errors; }
    298 }
    299 
    300 template< typename pass_type >
    301229void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
    302230        handleStatementList( statements, [this]( Statement *& stmt) {
    … …  
    347275
    348276template< typename pass_type >
    349 void PassVisitor< pass_type >::visitStatement( const Statement * stmt ) {
    350         if ( ! get_visit_children() ) return;
    351 
    352         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
    353         ValueGuardPtr< typename std::remove_pointer<decltype(get_env_ptr())>::type >  oldEnv( get_env_ptr() );
    354 
    355         maybeAccept_impl( stmt, *this );
    356 }
    357 
    358 template< typename pass_type >
    359277Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
    360278        return handleStatement( stmt, [this]( Statement * stmt ) {
    … …  
    388306
    389307template< typename pass_type >
    390 void PassVisitor< pass_type >::visitExpression( const Expression * expr ) {
    391         if ( ! get_visit_children() ) return;
    392         if( !expr ) return;
    393 
    394         auto env_ptr = get_env_ptr();
    395         if ( env_ptr && expr->get_env() ) {
    396                 *env_ptr = expr->get_env();
    397         }
    398 
    399         maybeAccept_impl( expr, *this );
    400 }
    401 
    402 template< typename pass_type >
    403308Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
    404309        return handleExpression(expr, [this]( Expression * expr ) {
    … …  
    410315template< typename TreeType, typename VisitorType >
    411316inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
    412         if ( ! visitor.get_visit_children() ) return;
    413         auto guard = makeFuncGuard(
    414                 [&visitor]() { visitor.indexerScopeEnter(); },
    415                 [&visitor]() { visitor.indexerScopeLeave(); }
    416         );
    417         maybeAccept_impl( tree, visitor );
    418 }
    419 
    420 template< typename TreeType, typename VisitorType >
    421 inline void indexerScopedAccept( const TreeType * tree, VisitorType & visitor ) {
    422317        if ( ! visitor.get_visit_children() ) return;
    423318        auto guard = makeFuncGuard(
    … …  
    477372
    478373        indexerAddId( node );
    479 
    480         VISIT_END( node );
    481 }
    482 
    483 template< typename pass_type >
    484 void PassVisitor< pass_type >::visit( const ObjectDecl * node ) {
    485         VISIT_START( node );
    486 
    487         maybeAccept_impl( node->type         , *this );
    488         maybeAccept_impl( node->init         , *this );
    489         maybeAccept_impl( node->bitfieldWidth, *this );
    490         maybeAccept_impl( node->attributes   , *this );
    491374
    492375        VISIT_END( node );
    … …  
    545428
    546429template< typename pass_type >
    547 void PassVisitor< pass_type >::visit( const FunctionDecl * node ) {
    548         VISIT_START( node );
    549 
    550         maybeAccept_impl( node->withExprs, *this );
    551         {
    552                 // implicit add __func__ identifier as specified in the C manual 6.4.2.2
    553                 static ObjectDecl func(
    554                         "__func__", noStorageClasses, LinkageSpec::C, nullptr,
    555                         new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
    556                         nullptr
    557                 );
    558                 maybeAccept_impl( node->type, *this );
    559                 // function body needs to have the same scope as parameters - CompoundStmt will not enter
    560                 // a new scope if inFunction is true
    561                 ValueGuard< bool > oldInFunction( inFunction );
    562                 inFunction = true;
    563                 maybeAccept_impl( node->statements, *this );
    564                 maybeAccept_impl( node->attributes, *this );
    565         }
    566 
    567         VISIT_END( node );
    568 }
    569 
    570 template< typename pass_type >
    571430DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {
    572431        MUTATE_START( node );
    … …  
    625484
    626485template< typename pass_type >
    627 void PassVisitor< pass_type >::visit( const StructDecl * node ) {
    628         VISIT_START( node );
    629 
    630         maybeAccept_impl( node->parameters, *this );
    631         maybeAccept_impl( node->members   , *this );
    632 
    633         VISIT_END( node );
    634 }
    635 
    636 template< typename pass_type >
    637486Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {
    638487        MUTATE_START( node );
    … …  
    673522        VISIT_END( node );
    674523}
    675 template< typename pass_type >
    676 void PassVisitor< pass_type >::visit( const UnionDecl * node ) {
    677         VISIT_START( node );
    678 
    679         maybeAccept_impl( node->parameters, *this );
    680         maybeAccept_impl( node->members   , *this );
    681 
    682         VISIT_END( node );
    683 }
    684524
    685525template< typename pass_type >
    … …  
    717557
    718558template< typename pass_type >
    719 void PassVisitor< pass_type >::visit( const EnumDecl * node ) {
    720         VISIT_START( node );
    721 
    722         // unlike structs, traits, and unions, enums inject their members into the global scope
    723         maybeAccept_impl( node->parameters, *this );
    724         maybeAccept_impl( node->members   , *this );
    725 
    726         VISIT_END( node );
    727 }
    728 
    729 template< typename pass_type >
    730559Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {
    731560        MUTATE_START( node );
    … …  
    758587
    759588template< typename pass_type >
    760 void PassVisitor< pass_type >::visit( const TraitDecl * node ) {
    761         VISIT_START( node );
    762 
    763         maybeAccept_impl( node->parameters, *this );
    764         maybeAccept_impl( node->members   , *this );
    765 
    766         VISIT_END( node );
    767 }
    768 
    769 template< typename pass_type >
    770589Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {
    771590        MUTATE_START( node );
    … …  
    806625}
    807626
    808 
    809 template< typename pass_type >
    810 void PassVisitor< pass_type >::visit( const TypeDecl * node ) {
    811         VISIT_START( node );
    812 
    813         maybeAccept_impl( node->parameters, *this );
    814         maybeAccept_impl( node->base      , *this );
    815         maybeAccept_impl( node->assertions, *this );
    816 
    817         VISIT_END( node );
    818 }
    819 
    820627template< typename pass_type >
    821628Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) {
    … …  
    860667
    861668template< typename pass_type >
    862 void PassVisitor< pass_type >::visit( const TypedefDecl * node ) {
    863         VISIT_START( node );
    864 
    865         maybeAccept_impl( node->parameters, *this );
    866         maybeAccept_impl( node->base      , *this );
    867         maybeAccept_impl( node->assertions, *this );
    868 
    869         VISIT_END( node );
    870 }
    871 
    872 template< typename pass_type >
    873669Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {
    874670        MUTATE_START( node );
    … …  
    899695
    900696template< typename pass_type >
    901 void PassVisitor< pass_type >::visit( const AsmDecl * node ) {
    902         VISIT_START( node );
    903 
    904         maybeAccept_impl( node->stmt, *this );
    905 
    906         VISIT_END( node );
    907 }
    908 
    909 template< typename pass_type >
    910697AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {
    911698        MUTATE_START( node );
    … …  
    923710
    924711        node->condition = visitExpression( node->condition );
    925         maybeAccept_impl( node->message, *this );
    926 
    927         VISIT_END( node );
    928 }
    929 
    930 template< typename pass_type >
    931 void PassVisitor< pass_type >::visit( const StaticAssertDecl * node ) {
    932         VISIT_START( node );
    933 
    934         visitExpression( node->condition );
    935712        maybeAccept_impl( node->message, *this );
    936713
    … …  
    965742
    966743template< typename pass_type >
    967 void PassVisitor< pass_type >::visit( const CompoundStmt * node ) {
    968         VISIT_START( node );
    969         {
    970                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
    971                 ValueGuard< bool > oldInFunction( inFunction );
    972                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
    973                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
    974                 inFunction = false;
    975                 visitStatementList( node->kids );
    976         }
    977         VISIT_END( node );
    978 }
    979 
    980 template< typename pass_type >
    981744CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) {
    982745        MUTATE_START( node );
    … …  
    1004767
    1005768template< typename pass_type >
    1006 void PassVisitor< pass_type >::visit( const ExprStmt * node ) {
    1007         VISIT_START( node );
    1008 
    1009         visitExpression( node->expr );
    1010 
    1011         VISIT_END( node );
    1012 }
    1013 
    1014 template< typename pass_type >
    1015769Statement * PassVisitor< pass_type >::mutate( ExprStmt * node ) {
    1016770        MUTATE_START( node );
    … …  
    1036790
    1037791template< typename pass_type >
    1038 void PassVisitor< pass_type >::visit( const AsmStmt * node ) {
    1039         VISIT_START( node )
    1040 
    1041         maybeAccept_impl( node->instruction, *this );
    1042         maybeAccept_impl( node->output, *this );
    1043         maybeAccept_impl( node->input, *this );
    1044         maybeAccept_impl( node->clobber, *this );
    1045 
    1046         VISIT_END( node );
    1047 }
    1048 
    1049 template< typename pass_type >
    1050792Statement * PassVisitor< pass_type >::mutate( AsmStmt * node ) {
    1051793        MUTATE_START( node );
    … …  
    1069811
    1070812template< typename pass_type >
    1071 void PassVisitor< pass_type >::visit( const DirectiveStmt * node ) {
    1072         VISIT_START( node )
    1073 
    1074         VISIT_END( node );
    1075 }
    1076 
    1077 template< typename pass_type >
    1078813Statement * PassVisitor< pass_type >::mutate( DirectiveStmt * node ) {
    1079814        MUTATE_START( node );
    … …  
    1090825                // if statements introduce a level of scope (for the initialization)
    1091826                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1092                 maybeAccept_impl( node->initialization, *this );
     827                maybeAccept_impl( node->get_initialization(), *this );
    1093828                visitExpression ( node->condition );
    1094829                node->thenPart = visitStatement( node->thenPart );
    … …  
    1099834
    1100835template< typename pass_type >
    1101 void PassVisitor< pass_type >::visit( const IfStmt * node ) {
    1102         VISIT_START( node );
    1103 
    1104         maybeAccept_impl( node->initialization, *this );
    1105         visitExpression ( node->condition );
    1106         visitStatement( node->thenPart );
    1107         visitStatement( node->elsePart );
    1108 
    1109         VISIT_END( node );
    1110 }
    1111 
    1112 template< typename pass_type >
    1113836Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) {
    1114837        MUTATE_START( node );
    … …  
    1116839                // if statements introduce a level of scope (for the initialization)
    1117840                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    1118                 maybeMutate_impl( node->initialization, *this );
     841                maybeMutate_impl( node->get_initialization(), *this );
    1119842                node->condition = mutateExpression( node->condition );
    1120843                node->thenPart  = mutateStatement ( node->thenPart  );
    … …  
    1137860                node->body = visitStatement( node->body );
    1138861        }
    1139 
    1140         VISIT_END( node );
    1141 }
    1142 
    1143 template< typename pass_type >
    1144 void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
    1145         VISIT_START( node );
    1146 
    1147         maybeAccept_impl( node->initialization, *this );
    1148         visitExpression ( node->condition );
    1149         visitStatement( node->body );
    1150862
    1151863        VISIT_END( node );
    … …  
    1185897
    1186898template< typename pass_type >
    1187 void PassVisitor< pass_type >::visit( const ForStmt * node ) {
    1188         VISIT_START( node );
    1189 
    1190         maybeAccept_impl( node->initialization, *this );
    1191         visitExpression( node->condition );
    1192         visitExpression( node->increment );
    1193         visitStatement( node->body );
    1194 
    1195         VISIT_END( node );
    1196 }
    1197 
    1198 template< typename pass_type >
    1199899Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) {
    1200900        MUTATE_START( node );
    … …  
    1223923
    1224924template< typename pass_type >
    1225 void PassVisitor< pass_type >::visit( const SwitchStmt * node ) {
    1226         VISIT_START( node );
    1227 
    1228         visitExpression   ( node->condition  );
    1229         visitStatementList( node->statements );
    1230 
    1231         VISIT_END( node );
    1232 }
    1233 
    1234 template< typename pass_type >
    1235925Statement * PassVisitor< pass_type >::mutate( SwitchStmt * node ) {
    1236926        MUTATE_START( node );
    … …  
    1255945
    1256946template< typename pass_type >
    1257 void PassVisitor< pass_type >::visit( const CaseStmt * node ) {
    1258         VISIT_START( node );
    1259 
    1260         visitExpression   ( node->condition );
    1261         visitStatementList( node->stmts     );
    1262 
    1263         VISIT_END( node );
    1264 }
    1265 
    1266 template< typename pass_type >
    1267947Statement * PassVisitor< pass_type >::mutate( CaseStmt * node ) {
    1268948        MUTATE_START( node );
    … …  
    1283963
    1284964template< typename pass_type >
    1285 void PassVisitor< pass_type >::visit( const BranchStmt * node ) {
    1286         VISIT_START( node );
    1287         VISIT_END( node );
    1288 }
    1289 
    1290 template< typename pass_type >
    1291965Statement * PassVisitor< pass_type >::mutate( BranchStmt * node ) {
    1292966        MUTATE_START( node );
    … …  
    1306980
    1307981template< typename pass_type >
    1308 void PassVisitor< pass_type >::visit( const ReturnStmt * node ) {
    1309         VISIT_START( node );
    1310 
    1311         visitExpression( node->expr );
    1312 
    1313         VISIT_END( node );
    1314 }
    1315 
    1316 template< typename pass_type >
    1317982Statement * PassVisitor< pass_type >::mutate( ReturnStmt * node ) {
    1318983        MUTATE_START( node );
    … …  
    1325990//--------------------------------------------------------------------------
    1326991// ThrowStmt
     992
    1327993template< typename pass_type >
    1328994void PassVisitor< pass_type >::visit( ThrowStmt * node ) {
    … …  
    13361002
    13371003template< typename pass_type >
    1338 void PassVisitor< pass_type >::visit( const ThrowStmt * node ) {
    1339         VISIT_START( node );
    1340 
    1341         maybeAccept_impl( node->expr, *this );
    1342         maybeAccept_impl( node->target, *this );
    1343 
    1344         VISIT_END( node );
    1345 }
    1346 
    1347 template< typename pass_type >
    13481004Statement * PassVisitor< pass_type >::mutate( ThrowStmt * node ) {
    13491005        MUTATE_START( node );
    … …  
    13591015template< typename pass_type >
    13601016void PassVisitor< pass_type >::visit( TryStmt * node ) {
    1361         VISIT_START( node );
    1362 
    1363         maybeAccept_impl( node->block       , *this );
    1364         maybeAccept_impl( node->handlers    , *this );
    1365         maybeAccept_impl( node->finallyBlock, *this );
    1366 
    1367         VISIT_END( node );
    1368 }
    1369 
    1370 template< typename pass_type >
    1371 void PassVisitor< pass_type >::visit( const TryStmt * node ) {
    13721017        VISIT_START( node );
    13731018
    … …  
    14061051
    14071052template< typename pass_type >
    1408 void PassVisitor< pass_type >::visit( const CatchStmt * node ) {
    1409         VISIT_START( node );
    1410 
    1411         maybeAccept_impl( node->decl, *this );
    1412         visitExpression( node->cond );
    1413         visitStatement ( node->body );
    1414 
    1415         VISIT_END( node );
    1416 }
    1417 
    1418 template< typename pass_type >
    14191053Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) {
    14201054        MUTATE_START( node );
    … …  
    14411075
    14421076template< typename pass_type >
    1443 void PassVisitor< pass_type >::visit( const FinallyStmt * node ) {
    1444         VISIT_START( node );
    1445 
    1446         maybeAccept_impl( node->block, *this );
    1447 
    1448         VISIT_END( node );
    1449 }
    1450 
    1451 template< typename pass_type >
    14521077Statement * PassVisitor< pass_type >::mutate( FinallyStmt * node ) {
    14531078        MUTATE_START( node );
    … …  
    14821107
    14831108template< typename pass_type >
    1484 void PassVisitor< pass_type >::visit( const WaitForStmt * node ) {
    1485         VISIT_START( node );
    1486 
    1487         for( auto & clause : node->clauses ) {
    1488                 maybeAccept_impl( clause.target.function, *this );
    1489                 maybeAccept_impl( clause.target.arguments, *this );
    1490 
    1491                 maybeAccept_impl( clause.statement, *this );
    1492                 maybeAccept_impl( clause.condition, *this );
    1493         }
    1494 
    1495         maybeAccept_impl( node->timeout.time, *this );
    1496         maybeAccept_impl( node->timeout.statement, *this );
    1497         maybeAccept_impl( node->timeout.condition, *this );
    1498         maybeAccept_impl( node->orelse.statement, *this );
    1499         maybeAccept_impl( node->orelse.condition, *this );
    1500 
    1501         VISIT_END( node );
    1502 }
    1503 
    1504 template< typename pass_type >
    15051109Statement * PassVisitor< pass_type >::mutate( WaitForStmt * node ) {
    15061110        MUTATE_START( node );
    … …  
    15261130
    15271131//--------------------------------------------------------------------------
    1528 // WithStmt
     1132// NullStmt
    15291133template< typename pass_type >
    15301134void PassVisitor< pass_type >::visit( WithStmt * node ) {
    … …  
    15411145
    15421146template< typename pass_type >
    1543 void PassVisitor< pass_type >::visit( const WithStmt * node ) {
    1544         VISIT_START( node );
    1545 
    1546         maybeAccept_impl( node->exprs, *this );
    1547         maybeAccept_impl( node->stmt, *this );
    1548 
    1549         VISIT_END( node );
    1550 }
    1551 
    1552 template< typename pass_type >
    15531147Statement * PassVisitor< pass_type >::mutate( WithStmt * node ) {
    15541148        MUTATE_START( node );
    … …  
    15721166
    15731167template< typename pass_type >
    1574 void PassVisitor< pass_type >::visit( const NullStmt * node ) {
    1575         VISIT_START( node );
    1576         VISIT_END( node );
    1577 }
    1578 
    1579 template< typename pass_type >
    15801168NullStmt * PassVisitor< pass_type >::mutate( NullStmt * node ) {
    15811169        MUTATE_START( node );
    … …  
    15951183
    15961184template< typename pass_type >
    1597 void PassVisitor< pass_type >::visit( const DeclStmt * node ) {
    1598         VISIT_START( node );
    1599 
    1600         maybeAccept_impl( node->decl, *this );
    1601 
    1602         VISIT_END( node );
    1603 }
    1604 
    1605 template< typename pass_type >
    16061185Statement * PassVisitor< pass_type >::mutate( DeclStmt * node ) {
    16071186        MUTATE_START( node );
    … …  
    16161195template< typename pass_type >
    16171196void PassVisitor< pass_type >::visit( ImplicitCtorDtorStmt * node ) {
    1618         VISIT_START( node );
    1619 
    1620         maybeAccept_impl( node->callStmt, *this );
    1621 
    1622         VISIT_END( node );
    1623 }
    1624 
    1625 template< typename pass_type >
    1626 void PassVisitor< pass_type >::visit( const ImplicitCtorDtorStmt * node ) {
    16271197        VISIT_START( node );
    16281198
    … …  
    16501220        maybeAccept_impl        ( node->function, *this );
    16511221        maybeAccept_impl        ( node->args    , *this );
    1652 
    1653         VISIT_END( node );
    1654 }
    1655 
    1656 template< typename pass_type >
    1657 void PassVisitor< pass_type >::visit( const ApplicationExpr * node ) {
    1658         VISIT_START( node );
    1659 
    1660         maybeAccept_impl( node->result  , *this );
    1661         maybeAccept_impl( node->function, *this );
    1662         maybeAccept_impl( node->args    , *this );
    16631222
    16641223        VISIT_END( node );
    … …  
    16941253
    16951254template< typename pass_type >
    1696 void PassVisitor< pass_type >::visit( const UntypedExpr * node ) {
    1697         VISIT_START( node );
    1698 
    1699         maybeAccept_impl( node->result, *this );
    1700 
    1701         for ( auto expr : node->args ) {
    1702                 visitExpression( expr );
    1703         }
    1704 
    1705         VISIT_END( node );
    1706 }
    1707 
    1708 template< typename pass_type >
    17091255Expression * PassVisitor< pass_type >::mutate( UntypedExpr * node ) {
    17101256        MUTATE_START( node );
    … …  
    17321278
    17331279template< typename pass_type >
    1734 void PassVisitor< pass_type >::visit( const NameExpr * node ) {
    1735         VISIT_START( node );
    1736 
    1737         maybeAccept_impl( node->result, *this );
    1738 
    1739         VISIT_END( node );
    1740 }
    1741 
    1742 template< typename pass_type >
    17431280Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {
    17441281        MUTATE_START( node );
    … …  
    17631300
    17641301template< typename pass_type >
    1765 void PassVisitor< pass_type >::visit( const CastExpr * node ) {
    1766         VISIT_START( node );
    1767 
    1768         maybeAccept_impl( node->result, *this );
    1769         maybeAccept_impl( node->arg   , *this );
    1770 
    1771         VISIT_END( node );
    1772 }
    1773 
    1774 template< typename pass_type >
    17751302Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {
    17761303        MUTATE_START( node );
    … …  
    17961323
    17971324template< typename pass_type >
    1798 void PassVisitor< pass_type >::visit( const KeywordCastExpr * node ) {
    1799         VISIT_START( node );
    1800 
    1801         maybeAccept_impl( node->result, *this );
    1802         maybeAccept_impl( node->arg   , *this );
    1803 
    1804         VISIT_END( node );
    1805 }
    1806 
    1807 template< typename pass_type >
    18081325Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) {
    18091326        MUTATE_START( node );
    … …  
    18291346
    18301347template< typename pass_type >
    1831 void PassVisitor< pass_type >::visit( const VirtualCastExpr * node ) {
    1832         VISIT_START( node );
    1833 
    1834         maybeAccept_impl( node->result, *this );
    1835         maybeAccept_impl( node->arg, *this );
    1836 
    1837         VISIT_END( node );
    1838 }
    1839 
    1840 template< typename pass_type >
    18411348Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {
    18421349        MUTATE_START( node );
    … …  
    18621369
    18631370template< typename pass_type >
    1864 void PassVisitor< pass_type >::visit( const AddressExpr * node ) {
    1865         VISIT_START( node );
    1866 
    1867         maybeAccept_impl( node->result, *this );
    1868         maybeAccept_impl( node->arg   , *this );
    1869 
    1870         VISIT_END( node );
    1871 }
    1872 
    1873 template< typename pass_type >
    18741371Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {
    18751372        MUTATE_START( node );
    … …  
    18891386
    18901387        indexerScopedAccept( node->result, *this );
    1891 
    1892         VISIT_END( node );
    1893 }
    1894 
    1895 template< typename pass_type >
    1896 void PassVisitor< pass_type >::visit( const LabelAddressExpr * node ) {
    1897         VISIT_START( node );
    1898 
    1899         maybeAccept_impl( node->result, *this );
    19001388
    19011389        VISIT_END( node );
    … …  
    19211409        maybeAccept_impl   ( node->aggregate, *this );
    19221410        maybeAccept_impl   ( node->member   , *this );
    1923 
    1924         VISIT_END( node );
    1925 }
    1926 
    1927 template< typename pass_type >
    1928 void PassVisitor< pass_type >::visit( const UntypedMemberExpr * node ) {
    1929         VISIT_START( node );
    1930 
    1931         maybeAccept_impl( node->result   , *this );
    1932         maybeAccept_impl( node->aggregate, *this );
    1933         maybeAccept_impl( node->member   , *this );
    19341411
    19351412        VISIT_END( node );
    … …  
    19611438
    19621439template< typename pass_type >
    1963 void PassVisitor< pass_type >::visit( const MemberExpr * node ) {
    1964         VISIT_START( node );
    1965 
    1966         maybeAccept_impl( node->result   , *this );
    1967         maybeAccept_impl( node->aggregate, *this );
    1968 
    1969         VISIT_END( node );
    1970 }
    1971 
    1972 template< typename pass_type >
    19731440Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {
    19741441        MUTATE_START( node );
    … …  
    19931460
    19941461template< typename pass_type >
    1995 void PassVisitor< pass_type >::visit( const VariableExpr * node ) {
    1996         VISIT_START( node );
    1997 
    1998         maybeAccept_impl( node->result, *this );
    1999 
    2000         VISIT_END( node );
    2001 }
    2002 
    2003 template< typename pass_type >
    20041462Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {
    20051463        MUTATE_START( node );
    … …  
    20191477        indexerScopedAccept( node->result   , *this );
    20201478        maybeAccept_impl   ( &node->constant, *this );
    2021 
    2022         VISIT_END( node );
    2023 }
    2024 
    2025 template< typename pass_type >
    2026 void PassVisitor< pass_type >::visit( const ConstantExpr * node ) {
    2027         VISIT_START( node );
    2028 
    2029         maybeAccept_impl( node->result   , *this );
    2030         maybeAccept_impl( &node->constant, *this );
    20311479
    20321480        VISIT_END( node );
    … …  
    20631511
    20641512template< typename pass_type >
    2065 void PassVisitor< pass_type >::visit( const SizeofExpr * node ) {
    2066         VISIT_START( node );
    2067 
    2068         maybeAccept_impl( node->result, *this );
    2069         if ( node->get_isType() ) {
    2070                 maybeAccept_impl( node->type, *this );
    2071         } else {
    2072                 maybeAccept_impl( node->expr, *this );
    2073         }
    2074 
    2075         VISIT_END( node );
    2076 }
    2077 
    2078 template< typename pass_type >
    20791513Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {
    20801514        MUTATE_START( node );
    … …  
    21081542
    21091543template< typename pass_type >
    2110 void PassVisitor< pass_type >::visit( const AlignofExpr * node ) {
    2111         VISIT_START( node );
    2112 
    2113         maybeAccept_impl( node->result, *this );
    2114         if ( node->get_isType() ) {
    2115                 maybeAccept_impl( node->type, *this );
    2116         } else {
    2117                 maybeAccept_impl( node->expr, *this );
    2118         }
    2119 
    2120         VISIT_END( node );
    2121 }
    2122 
    2123 template< typename pass_type >
    21241544Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {
    21251545        MUTATE_START( node );
    … …  
    21491569
    21501570template< typename pass_type >
    2151 void PassVisitor< pass_type >::visit( const UntypedOffsetofExpr * node ) {
    2152         VISIT_START( node );
    2153 
    2154         maybeAccept_impl( node->result, *this );
    2155         maybeAccept_impl( node->type  , *this );
    2156 
    2157         VISIT_END( node );
    2158 }
    2159 
    2160 template< typename pass_type >
    21611571Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {
    21621572        MUTATE_START( node );
    … …  
    21821592
    21831593template< typename pass_type >
    2184 void PassVisitor< pass_type >::visit( const OffsetofExpr * node ) {
    2185         VISIT_START( node );
    2186 
    2187         maybeAccept_impl( node->result, *this );
    2188         maybeAccept_impl( node->type  , *this );
    2189 
    2190         VISIT_END( node );
    2191 }
    2192 
    2193 template< typename pass_type >
    21941594Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {
    21951595        MUTATE_START( node );
    … …  
    22101610        indexerScopedAccept( node->result, *this );
    22111611        maybeAccept_impl   ( node->type  , *this );
    2212 
    2213         VISIT_END( node );
    2214 }
    2215 
    2216 template< typename pass_type >
    2217 void PassVisitor< pass_type >::visit( const OffsetPackExpr * node ) {
    2218         VISIT_START( node );
    2219 
    2220         maybeAccept_impl( node->result, *this );
    2221         maybeAccept_impl( node->type  , *this );
    22221612
    22231613        VISIT_END( node );
    … …  
    22521642
    22531643template< typename pass_type >
    2254 void PassVisitor< pass_type >::visit( const AttrExpr * node ) {
    2255         VISIT_START( node );
    2256 
    2257         maybeAccept_impl( node->result, *this );
    2258         if ( node->get_isType() ) {
    2259                 maybeAccept_impl( node->type, *this );
    2260         } else {
    2261                 maybeAccept_impl( node->expr, *this );
    2262         }
    2263 
    2264         VISIT_END( node );
    2265 }
    2266 
    2267 template< typename pass_type >
    22681644Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {
    22691645        MUTATE_START( node );
    … …  
    22941670
    22951671template< typename pass_type >
    2296 void PassVisitor< pass_type >::visit( const LogicalExpr * node ) {
    2297         VISIT_START( node );
    2298 
    2299         maybeAccept_impl( node->result, *this );
    2300         maybeAccept_impl( node->arg1  , *this );
    2301         maybeAccept_impl( node->arg2  , *this );
    2302 
    2303         VISIT_END( node );
    2304 }
    2305 
    2306 template< typename pass_type >
    23071672Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {
    23081673        MUTATE_START( node );
    … …  
    23311696
    23321697template< typename pass_type >
    2333 void PassVisitor< pass_type >::visit( const ConditionalExpr * node ) {
    2334         VISIT_START( node );
    2335 
    2336         maybeAccept_impl( node->result, *this );
    2337         maybeAccept_impl( node->arg1  , *this );
    2338         maybeAccept_impl( node->arg2  , *this );
    2339         maybeAccept_impl( node->arg3  , *this );
    2340 
    2341         VISIT_END( node );
    2342 }
    2343 
    2344 template< typename pass_type >
    23451698Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {
    23461699        MUTATE_START( node );
    … …  
    23691722
    23701723template< typename pass_type >
    2371 void PassVisitor< pass_type >::visit( const CommaExpr * node ) {
    2372         VISIT_START( node );
    2373 
    2374         maybeAccept_impl( node->result, *this );
    2375         maybeAccept_impl( node->arg1  , *this );
    2376         maybeAccept_impl( node->arg2  , *this );
    2377 
    2378         VISIT_END( node );
    2379 }
    2380 
    2381 template< typename pass_type >
    23821724Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {
    23831725        MUTATE_START( node );
    … …  
    23991741        indexerScopedAccept( node->result, *this );
    24001742        maybeAccept_impl   ( node->type, *this );
    2401 
    2402         VISIT_END( node );
    2403 }
    2404 
    2405 template< typename pass_type >
    2406 void PassVisitor< pass_type >::visit( const TypeExpr * node ) {
    2407         VISIT_START( node );
    2408 
    2409         maybeAccept_impl( node->result, *this );
    2410         maybeAccept_impl( node->type, *this );
    24111743
    24121744        VISIT_END( node );
    … …  
    24341766        maybeAccept_impl   ( node->constraint, *this );
    24351767        maybeAccept_impl   ( node->operand   , *this );
    2436 
    2437         VISIT_END( node );
    2438 }
    2439 
    2440 template< typename pass_type >
    2441 void PassVisitor< pass_type >::visit( const AsmExpr * node ) {
    2442         VISIT_START( node );
    2443 
    2444         maybeAccept_impl( node->result    , *this );
    2445         maybeAccept_impl( node->inout     , *this );
    2446         maybeAccept_impl( node->constraint, *this );
    2447         maybeAccept_impl( node->operand   , *this );
    24481768
    24491769        VISIT_END( node );
    … …  
    24761796
    24771797template< typename pass_type >
    2478 void PassVisitor< pass_type >::visit( const ImplicitCopyCtorExpr * node ) {
    2479         VISIT_START( node );
    2480 
    2481         maybeAccept_impl( node->result    , *this );
    2482         maybeAccept_impl( node->callExpr  , *this );
    2483 
    2484         VISIT_END( node );
    2485 }
    2486 
    2487 template< typename pass_type >
    24881798Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {
    24891799        MUTATE_START( node );
    … …  
    25091819
    25101820template< typename pass_type >
    2511 void PassVisitor< pass_type >::visit( const ConstructorExpr * node ) {
    2512         VISIT_START( node );
    2513 
    2514         maybeAccept_impl( node->result  , *this );
    2515         maybeAccept_impl( node->callExpr, *this );
    2516 
    2517         VISIT_END( node );
    2518 }
    2519 
    2520 template< typename pass_type >
    25211821Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {
    25221822        MUTATE_START( node );
    … …  
    25421842
    25431843template< typename pass_type >
    2544 void PassVisitor< pass_type >::visit( const CompoundLiteralExpr * node ) {
    2545         VISIT_START( node );
    2546 
    2547         maybeAccept_impl( node->result     , *this );
    2548         maybeAccept_impl( node->initializer, *this );
    2549 
    2550         VISIT_END( node );
    2551 }
    2552 
    2553 template< typename pass_type >
    25541844Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {
    25551845        MUTATE_START( node );
    … …  
    25761866
    25771867template< typename pass_type >
    2578 void PassVisitor< pass_type >::visit( const RangeExpr * node ) {
    2579         VISIT_START( node );
    2580 
    2581         maybeAccept_impl( node->result, *this );
    2582         maybeAccept_impl( node->low   , *this );
    2583         maybeAccept_impl( node->high  , *this );
    2584 
    2585         VISIT_END( node );
    2586 }
    2587 
    2588 template< typename pass_type >
    25891868Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {
    25901869        MUTATE_START( node );
    … …  
    26111890
    26121891template< typename pass_type >
    2613 void PassVisitor< pass_type >::visit( const UntypedTupleExpr * node ) {
    2614         VISIT_START( node );
    2615 
    2616         maybeAccept_impl( node->result, *this );
    2617         maybeAccept_impl( node->exprs , *this );
    2618 
    2619         VISIT_END( node );
    2620 }
    2621 
    2622 template< typename pass_type >
    26231892Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {
    26241893        MUTATE_START( node );
    … …  
    26441913
    26451914template< typename pass_type >
    2646 void PassVisitor< pass_type >::visit( const TupleExpr * node ) {
    2647         VISIT_START( node );
    2648 
    2649         maybeAccept_impl( node->result, *this );
    2650         maybeAccept_impl( node->exprs , *this );
    2651 
    2652         VISIT_END( node );
    2653 }
    2654 
    2655 template< typename pass_type >
    26561915Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {
    26571916        MUTATE_START( node );
    … …  
    26771936
    26781937template< typename pass_type >
    2679 void PassVisitor< pass_type >::visit( const TupleIndexExpr * node ) {
    2680         VISIT_START( node );
    2681 
    2682         maybeAccept_impl( node->result, *this );
    2683         maybeAccept_impl( node->tuple , *this );
    2684 
    2685         VISIT_END( node );
    2686 }
    2687 
    2688 template< typename pass_type >
    26891938Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {
    26901939        MUTATE_START( node );
    … …  
    27051954        indexerScopedAccept( node->result  , *this );
    27061955        maybeAccept_impl   ( node->stmtExpr, *this );
    2707 
    2708         VISIT_END( node );
    2709 }
    2710 
    2711 template< typename pass_type >
    2712 void PassVisitor< pass_type >::visit( const TupleAssignExpr * node ) {
    2713         VISIT_START( node );
    2714 
    2715         maybeAccept_impl( node->result  , *this );
    2716         maybeAccept_impl( node->stmtExpr, *this );
    27171956
    27181957        VISIT_END( node );
    … …  
    27501989
    27511990template< typename pass_type >
    2752 void PassVisitor< pass_type >::visit( const StmtExpr * node ) {
    2753         VISIT_START( node );
    2754 
    2755         maybeAccept_impl( node->result     , *this );
    2756         maybeAccept_impl( node->statements , *this );
    2757         maybeAccept_impl( node->returnDecls, *this );
    2758         maybeAccept_impl( node->dtors      , *this );
    2759 
    2760         VISIT_END( node );
    2761 }
    2762 
    2763 template< typename pass_type >
    27641991Expression * PassVisitor< pass_type >::mutate( StmtExpr * node ) {
    27651992        MUTATE_START( node );
    … …  
    27912018
    27922019template< typename pass_type >
    2793 void PassVisitor< pass_type >::visit( const UniqueExpr * node ) {
    2794         VISIT_START( node );
    2795 
    2796         maybeAccept_impl( node->result, *this );
    2797         maybeAccept_impl( node->expr  , *this );
    2798 
    2799         VISIT_END( node );
    2800 }
    2801 
    2802 template< typename pass_type >
    28032020Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {
    28042021        MUTATE_START( node );
    … …  
    28252042
    28262043template< typename pass_type >
    2827 void PassVisitor< pass_type >::visit( const UntypedInitExpr * node ) {
    2828         VISIT_START( node );
    2829 
    2830         maybeAccept_impl( node->result, *this );
    2831         maybeAccept_impl( node->expr  , *this );
    2832         // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
    2833 
    2834         VISIT_END( node );
    2835 }
    2836 
    2837 template< typename pass_type >
    28382044Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
    28392045        MUTATE_START( node );
    … …  
    28612067
    28622068template< typename pass_type >
    2863 void PassVisitor< pass_type >::visit( const InitExpr * node ) {
    2864         VISIT_START( node );
    2865 
    2866         maybeAccept_impl( node->result, *this );
    2867         maybeAccept_impl( node->expr  , *this );
    2868         maybeAccept_impl( node->designation, *this );
    2869 
    2870         VISIT_END( node );
    2871 }
    2872 
    2873 template< typename pass_type >
    28742069Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
    28752070        MUTATE_START( node );
    … …  
    28972092
    28982093template< typename pass_type >
    2899 void PassVisitor< pass_type >::visit( const DeletedExpr * node ) {
    2900         VISIT_START( node );
    2901 
    2902         maybeAccept_impl( node->result, *this );
    2903         maybeAccept_impl( node->expr, *this );
    2904         // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
    2905 
    2906         VISIT_END( node );
    2907 }
    2908 
    2909 template< typename pass_type >
    29102094Expression * PassVisitor< pass_type >::mutate( DeletedExpr * node ) {
    29112095        MUTATE_START( node );
    … …  
    29252109
    29262110        indexerScopedAccept( node->result, *this );
    2927         maybeAccept_impl( node->expr, *this );
    2928 
    2929         VISIT_END( node );
    2930 }
    2931 
    2932 template< typename pass_type >
    2933 void PassVisitor< pass_type >::visit( const DefaultArgExpr * node ) {
    2934         VISIT_START( node );
    2935 
    2936         maybeAccept_impl( node->result, *this );
    29372111        maybeAccept_impl( node->expr, *this );
    29382112
    … …  
    29682142
    29692143template< typename pass_type >
    2970 void PassVisitor< pass_type >::visit( const GenericExpr * node ) {
    2971         VISIT_START( node );
    2972 
    2973         maybeAccept_impl( node->result, *this );
    2974         maybeAccept_impl( node->control, *this );
    2975         for ( const GenericExpr::Association & assoc : node->associations ) {
    2976                 maybeAccept_impl( assoc.type, *this );
    2977                 maybeAccept_impl( assoc.expr, *this );
    2978         }
    2979 
    2980         VISIT_END( node );
    2981 }
    2982 
    2983 template< typename pass_type >
    29842144Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) {
    29852145        MUTATE_START( node );
    … …  
    30082168
    30092169template< typename pass_type >
    3010 void PassVisitor< pass_type >::visit( const VoidType * node ) {
    3011         VISIT_START( node );
    3012 
    3013         maybeAccept_impl( node->forall, *this );
    3014 
    3015         VISIT_END( node );
    3016 }
    3017 
    3018 template< typename pass_type >
    30192170Type * PassVisitor< pass_type >::mutate( VoidType * node ) {
    30202171        MUTATE_START( node );
    … …  
    30292180template< typename pass_type >
    30302181void PassVisitor< pass_type >::visit( BasicType * node ) {
    3031         VISIT_START( node );
    3032 
    3033         maybeAccept_impl( node->forall, *this );
    3034 
    3035         VISIT_END( node );
    3036 }
    3037 
    3038 template< typename pass_type >
    3039 void PassVisitor< pass_type >::visit( const BasicType * node ) {
    30402182        VISIT_START( node );
    30412183
    … …  
    30682210
    30692211template< typename pass_type >
    3070 void PassVisitor< pass_type >::visit( const PointerType * node ) {
    3071         VISIT_START( node );
    3072 
    3073         maybeAccept_impl( node->forall, *this );
    3074         // xxx - should PointerType visit/mutate dimension?
    3075         maybeAccept_impl( node->base, *this );
    3076 
    3077         VISIT_END( node );
    3078 }
    3079 
    3080 template< typename pass_type >
    30812212Type * PassVisitor< pass_type >::mutate( PointerType * node ) {
    30822213        MUTATE_START( node );
    … …  
    31032234
    31042235template< typename pass_type >
    3105 void PassVisitor< pass_type >::visit( const ArrayType * node ) {
    3106         VISIT_START( node );
    3107 
    3108         maybeAccept_impl( node->forall, *this );
    3109         maybeAccept_impl( node->dimension, *this );
    3110         maybeAccept_impl( node->base, *this );
    3111 
    3112         VISIT_END( node );
    3113 }
    3114 
    3115 template< typename pass_type >
    31162236Type * PassVisitor< pass_type >::mutate( ArrayType * node ) {
    31172237        MUTATE_START( node );
    … …  
    31372257
    31382258template< typename pass_type >
    3139 void PassVisitor< pass_type >::visit( const ReferenceType * node ) {
    3140         VISIT_START( node );
    3141 
    3142         maybeAccept_impl( node->forall, *this );
    3143         maybeAccept_impl( node->base, *this );
    3144 
    3145         VISIT_END( node );
    3146 }
    3147 
    3148 template< typename pass_type >
    31492259Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
    31502260        MUTATE_START( node );
    … …  
    31702280
    31712281template< typename pass_type >
    3172 void PassVisitor< pass_type >::visit( const QualifiedType * node ) {
    3173         VISIT_START( node );
    3174 
    3175         maybeAccept_impl( node->forall, *this );
    3176         maybeAccept_impl( node->parent, *this );
    3177         maybeAccept_impl( node->child, *this );
    3178 
    3179         VISIT_END( node );
    3180 }
    3181 
    3182 template< typename pass_type >
    31832282Type * PassVisitor< pass_type >::mutate( QualifiedType * node ) {
    31842283        MUTATE_START( node );
    … …  
    31952294template< typename pass_type >
    31962295void PassVisitor< pass_type >::visit( FunctionType * node ) {
    3197         VISIT_START( node );
    3198 
    3199         maybeAccept_impl( node->forall, *this );
    3200         maybeAccept_impl( node->returnVals, *this );
    3201         maybeAccept_impl( node->parameters, *this );
    3202 
    3203         VISIT_END( node );
    3204 }
    3205 
    3206 template< typename pass_type >
    3207 void PassVisitor< pass_type >::visit( const FunctionType * node ) {
    32082296        VISIT_START( node );
    32092297
    … …  
    32442332
    32452333template< typename pass_type >
    3246 void PassVisitor< pass_type >::visit( const StructInstType * node ) {
    3247         VISIT_START( node );
    3248 
    3249         maybeAccept_impl( node->forall    , *this );
    3250         maybeAccept_impl( node->parameters, *this );
    3251 
    3252         VISIT_END( node );
    3253 }
    3254 
    3255 template< typename pass_type >
    32562334Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {
    32572335        MUTATE_START( node );
    … …  
    32862364
    32872365template< typename pass_type >
    3288 void PassVisitor< pass_type >::visit( const UnionInstType * node ) {
    3289         VISIT_START( node );
    3290 
    3291         maybeAccept_impl( node->forall    , *this );
    3292         maybeAccept_impl( node->parameters, *this );
    3293 
    3294         VISIT_END( node );
    3295 }
    3296 
    3297 template< typename pass_type >
    32982366Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {
    32992367        MUTATE_START( node );
    … …  
    33232391
    33242392template< typename pass_type >
    3325 void PassVisitor< pass_type >::visit( const EnumInstType * node ) {
    3326         VISIT_START( node );
    3327 
    3328         maybeAccept_impl( node->forall, *this );
    3329         maybeAccept_impl( node->parameters, *this );
    3330 
    3331         VISIT_END( node );
    3332 }
    3333 
    3334 template< typename pass_type >
    33352393Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {
    33362394        MUTATE_START( node );
    … …  
    33552413
    33562414template< typename pass_type >
    3357 void PassVisitor< pass_type >::visit( const TraitInstType * node ) {
    3358         VISIT_START( node );
    3359 
    3360         maybeAccept_impl( node->forall    , *this );
    3361         maybeAccept_impl( node->parameters, *this );
    3362 
    3363         VISIT_END( node );
    3364 }
    3365 
    3366 template< typename pass_type >
    33672415Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {
    33682416        MUTATE_START( node );
    … …  
    33782426template< typename pass_type >
    33792427void PassVisitor< pass_type >::visit( TypeInstType * node ) {
    3380         VISIT_START( node );
    3381 
    3382         maybeAccept_impl( node->forall    , *this );
    3383         maybeAccept_impl( node->parameters, *this );
    3384 
    3385         VISIT_END( node );
    3386 }
    3387 
    3388 template< typename pass_type >
    3389 void PassVisitor< pass_type >::visit( const TypeInstType * node ) {
    33902428        VISIT_START( node );
    33912429
    … …  
    34202458
    34212459template< typename pass_type >
    3422 void PassVisitor< pass_type >::visit( const TupleType * node ) {
    3423         VISIT_START( node );
    3424 
    3425         maybeAccept_impl( node->forall, *this );
    3426         maybeAccept_impl( node->types, *this );
    3427         maybeAccept_impl( node->members, *this );
    3428 
    3429         VISIT_END( node );
    3430 }
    3431 
    3432 template< typename pass_type >
    34332460Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
    34342461        MUTATE_START( node );
    … …  
    34452472template< typename pass_type >
    34462473void PassVisitor< pass_type >::visit( TypeofType * node ) {
    3447         VISIT_START( node );
    3448 
    3449         assert( node->expr );
    3450         maybeAccept_impl( node->expr, *this );
    3451 
    3452         VISIT_END( node );
    3453 }
    3454 
    3455 template< typename pass_type >
    3456 void PassVisitor< pass_type >::visit( const TypeofType * node ) {
    34572474        VISIT_START( node );
    34582475
    … …  
    34912508
    34922509template< typename pass_type >
    3493 void PassVisitor< pass_type >::visit( const AttrType * node ) {
    3494         VISIT_START( node );
    3495 
    3496         if ( node->isType ) {
    3497                 assert( node->type );
    3498                 maybeAccept_impl( node->type, *this );
    3499         } else {
    3500                 assert( node->expr );
    3501                 maybeAccept_impl( node->expr, *this );
    3502         } // if
    3503 
    3504         VISIT_END( node );
    3505 }
    3506 
    3507 template< typename pass_type >
    35082510Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
    35092511        MUTATE_START( node );
    … …  
    35322534
    35332535template< typename pass_type >
    3534 void PassVisitor< pass_type >::visit( const VarArgsType * node ) {
     2536Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
     2537        MUTATE_START( node );
     2538
     2539        maybeMutate_impl( node->forall, *this );
     2540
     2541        MUTATE_END( Type, node );
     2542}
     2543
     2544//--------------------------------------------------------------------------
     2545// ZeroType
     2546template< typename pass_type >
     2547void PassVisitor< pass_type >::visit( ZeroType * node ) {
    35352548        VISIT_START( node );
    35362549
    … …  
    35412554
    35422555template< typename pass_type >
    3543 Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
     2556Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
    35442557        MUTATE_START( node );
    35452558
    … …  
    35502563
    35512564//--------------------------------------------------------------------------
    3552 // ZeroType
    3553 template< typename pass_type >
    3554 void PassVisitor< pass_type >::visit( ZeroType * node ) {
     2565// OneType
     2566template< typename pass_type >
     2567void PassVisitor< pass_type >::visit( OneType * node ) {
    35552568        VISIT_START( node );
    35562569
    … …  
    35612574
    35622575template< typename pass_type >
    3563 void PassVisitor< pass_type >::visit( const ZeroType * node ) {
     2576Type * PassVisitor< pass_type >::mutate( OneType * node ) {
     2577        MUTATE_START( node );
     2578
     2579        maybeMutate_impl( node->forall, *this );
     2580
     2581        MUTATE_END( Type, node );
     2582}
     2583
     2584//--------------------------------------------------------------------------
     2585// GlobalScopeType
     2586template< typename pass_type >
     2587void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
    35642588        VISIT_START( node );
    35652589
    … …  
    35702594
    35712595template< typename pass_type >
    3572 Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
     2596Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
    35732597        MUTATE_START( node );
    35742598
    … …  
    35792603
    35802604//--------------------------------------------------------------------------
    3581 // OneType
    3582 template< typename pass_type >
    3583 void PassVisitor< pass_type >::visit( OneType * node ) {
    3584         VISIT_START( node );
    3585 
    3586         maybeAccept_impl( node->forall, *this );
    3587 
    3588         VISIT_END( node );
    3589 }
    3590 
    3591 template< typename pass_type >
    3592 void PassVisitor< pass_type >::visit( const OneType * node ) {
    3593         VISIT_START( node );
    3594 
    3595         maybeAccept_impl( node->forall, *this );
    3596 
    3597         VISIT_END( node );
    3598 }
    3599 
    3600 template< typename pass_type >
    3601 Type * PassVisitor< pass_type >::mutate( OneType * node ) {
    3602         MUTATE_START( node );
    3603 
    3604         maybeMutate_impl( node->forall, *this );
    3605 
    3606         MUTATE_END( Type, node );
    3607 }
    3608 
    3609 //--------------------------------------------------------------------------
    3610 // GlobalScopeType
    3611 template< typename pass_type >
    3612 void PassVisitor< pass_type >::visit( GlobalScopeType * node ) {
    3613         VISIT_START( node );
    3614 
    3615         maybeAccept_impl( node->forall, *this );
    3616 
    3617         VISIT_END( node );
    3618 }
    3619 
    3620 template< typename pass_type >
    3621 void PassVisitor< pass_type >::visit( const GlobalScopeType * node ) {
    3622         VISIT_START( node );
    3623 
    3624         maybeAccept_impl( node->forall, *this );
    3625 
    3626         VISIT_END( node );
    3627 }
    3628 
    3629 template< typename pass_type >
    3630 Type * PassVisitor< pass_type >::mutate( GlobalScopeType * node ) {
    3631         MUTATE_START( node );
    3632 
    3633         maybeMutate_impl( node->forall, *this );
    3634 
    3635         MUTATE_END( Type, node );
    3636 }
    3637 
    3638 //--------------------------------------------------------------------------
    36392605// Designation
    36402606template< typename pass_type >
    … …  
    36482614
    36492615template< typename pass_type >
    3650 void PassVisitor< pass_type >::visit( const Designation * node ) {
    3651         VISIT_START( node );
    3652 
    3653         maybeAccept_impl( node->designators, *this );
    3654 
    3655         VISIT_END( node );
    3656 }
    3657 
    3658 template< typename pass_type >
    36592616Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
    36602617        MUTATE_START( node );
    … …  
    36772634
    36782635template< typename pass_type >
    3679 void PassVisitor< pass_type >::visit( const SingleInit * node ) {
    3680         VISIT_START( node );
    3681 
    3682         visitExpression( node->value );
    3683 
    3684         VISIT_END( node );
    3685 }
    3686 
    3687 template< typename pass_type >
    36882636Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
    36892637        MUTATE_START( node );
    … …  
    36982646template< typename pass_type >
    36992647void PassVisitor< pass_type >::visit( ListInit * node ) {
    3700         VISIT_START( node );
    3701 
    3702         maybeAccept_impl( node->designations, *this );
    3703         maybeAccept_impl( node->initializers, *this );
    3704 
    3705         VISIT_END( node );
    3706 }
    3707 
    3708 template< typename pass_type >
    3709 void PassVisitor< pass_type >::visit( const ListInit * node ) {
    37102648        VISIT_START( node );
    37112649
    … …  
    37402678
    37412679template< typename pass_type >
    3742 void PassVisitor< pass_type >::visit( const ConstructorInit * node ) {
    3743         VISIT_START( node );
    3744 
    3745         maybeAccept_impl( node->ctor, *this );
    3746         maybeAccept_impl( node->dtor, *this );
    3747         maybeAccept_impl( node->init, *this );
    3748 
    3749         VISIT_END( node );
    3750 }
    3751 
    3752 template< typename pass_type >
    37532680Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
    37542681        MUTATE_START( node );
    … …  
    37712698
    37722699template< typename pass_type >
    3773 void PassVisitor< pass_type >::visit( const Constant * node ) {
    3774         VISIT_START( node );
    3775 
    3776         VISIT_END( node );
    3777 }
    3778 
    3779 template< typename pass_type >
    37802700Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
    37812701        MUTATE_START( node );
    … …  
    37882708template< typename pass_type >
    37892709void PassVisitor< pass_type >::visit( Attribute * node ) {
    3790         VISIT_START( node );
    3791 
    3792         maybeAccept_impl( node->parameters, *this );
    3793 
    3794         VISIT_END( node );
    3795 }
    3796 
    3797 template< typename pass_type >
    3798 void PassVisitor< pass_type >::visit( const Attribute * node ) {
    37992710        VISIT_START( node );
    38002711

  • src/Common/PassVisitor.proto.h

    rfce4e31 r302d84c2  
    118118static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {}
    119119
    120 template<typename pass_type, typename node_type>
    121 static inline auto previsit_impl( pass_type& pass, const node_type * node, __attribute__((unused)) int unused ) -> decltype( pass.previsit( node ), void() ) {
    122         pass.previsit( node );
    123 }
    124 
    125 template<typename pass_type, typename node_type>
    126 static inline void previsit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) const node_type * node, __attribute__((unused)) long unused ) {}
    127 
    128 
    129 template<typename pass_type, typename node_type>
    130 static inline auto postvisit_impl( pass_type& pass, const node_type * node, __attribute__((unused)) int unused ) -> decltype( pass.postvisit( node ), void() ) {
    131         pass.postvisit( node );
    132 }
    133 
    134 template<typename pass_type, typename node_type>
    135 static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) const node_type * node, __attribute__((unused)) long unused ) {}
    136 
    137120//---------------------------------------------------------
    138121// Mutate
    … …  
    217200        pass.indexer.func( arg );                                                                                                \
    218201}                                                                                                                              \
    219 template<typename pass_type>                                                                                                   \
    220 static inline void indexer_impl_##func ( pass_type &, long, type ) { }
     202                                                                                                                               \
     203template<typename pass_type>                                                                                                   \
     204static inline void indexer_impl_##func ( pass_type &, long, type ) { }                                                          \
    221205
    222206#define INDEXER_FUNC2( func, type1, type2 )                                                                                             \
    … …  
    225209        pass.indexer.func( arg1, arg2 );                                                                                                \
    226210}                                                                                                                              \
     211                                                                                                                               \
    227212template<typename pass_type>                                                                                                   \
    228213static inline void indexer_impl_##func ( pass_type &, long, type1, type2 ) { }
    … …  
    248233
    249234template<typename pass_type>
    250 static inline auto indexer_impl_addStructFwd( pass_type &, long, const StructDecl * ) {}
     235static inline auto indexer_impl_addStructFwd( pass_type &, long, StructDecl * ) {}
    251236
    252237template<typename pass_type>
    … …  
    258243
    259244template<typename pass_type>
    260 static inline auto indexer_impl_addUnionFwd( pass_type &, long, const UnionDecl * ) {}
     245static inline auto indexer_impl_addUnionFwd( pass_type &, long, UnionDecl * ) {}
    261246
    262247template<typename pass_type>

  • src/ResolvExpr/AdjustExprType.cc

    rfce4e31 r302d84c2  
    4747                void premutate( OneType * ) { visit_children = false; }
    4848
    49                 Type * postmutate( ArrayType * arrayType );
    50                 Type * postmutate( FunctionType * functionType );
    51                 Type * postmutate( TypeInstType * aggregateUseType );
     49                Type * postmutate( ArrayType *arrayType );
     50                Type * postmutate( FunctionType *functionType );
     51                Type * postmutate( TypeInstType *aggregateUseType );
    5252
    5353                private:
    … …  
    6161
    6262        Type * AdjustExprType_old::postmutate( ArrayType * arrayType ) {
    63                 PointerType * pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
     63                PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
    6464                arrayType->base = nullptr;
    6565                delete arrayType;
    … …  
    7272
    7373        Type * AdjustExprType_old::postmutate( TypeInstType * typeInst ) {
    74                 if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
     74                if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) {
    7575                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    7676                                return new PointerType{ Type::Qualifiers(), typeInst };
    7777                        }
    78                 } else if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    79                         if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl * >( ntDecl ) ) {
     78                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
     79                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    8080                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    8181                                        return new PointerType{ Type::Qualifiers(), typeInst };
    … …  
    8989void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    9090        PassVisitor<AdjustExprType_old> adjuster( env, indexer );
    91         Type * newType = type->acceptMutator( adjuster );
     91        Type *newType = type->acceptMutator( adjuster );
    9292        type = newType;
    9393}
    … …  
    148148} // anonymous namespace
    149149
    150 const ast::Type * adjustExprType(
    151         const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
     150const ast::Type * adjustExprType( 
     151        const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
    152152) {
    153153        ast::Pass<AdjustExprType_new> adjuster{ env, symtab };

  • src/ResolvExpr/CastCost.cc

    rfce4e31 r302d84c2  
    3737        struct CastCost_old : public ConversionCost {
    3838          public:
    39                 CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
     39                CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
    4040
    4141                using ConversionCost::previsit;
    4242                using ConversionCost::postvisit;
    43                 void postvisit( const BasicType * basicType );
    44                 void postvisit( const PointerType * pointerType );
     43                void postvisit( BasicType * basicType );
     44                void postvisit( PointerType * pointerType );
    4545        };
    4646
    47         Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    48                 if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
    49                         if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
     47        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     48                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
     49                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    5050                                if ( eqvClass->type ) {
    5151                                        return castCost( src, eqvClass->type, indexer, env );
    … …  
    5353                                        return Cost::infinity;
    5454                                }
    55                         } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
     55                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
    5656                                // all typedefs should be gone by this point
    57                                 const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
     57                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
    5858                                if ( type->base ) {
    5959                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
    … …  
    7474                        PRINT( std::cerr << "compatible!" << std::endl; )
    7575                        return Cost::zero;
    76                 } else if ( dynamic_cast< const VoidType * >( dest ) ) {
     76                } else if ( dynamic_cast< VoidType* >( dest ) ) {
    7777                        return Cost::safe;
    78                 } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
     78                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    7979                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    80                         return convertToReferenceCost( src, refType, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
     80                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    8181                                return ptrsCastable( t1, t2, env, indexer );
    8282                        });
    8383                } else {
    84                         PassVisitor<CastCost_old> converter(
    85                                 dest, indexer, env,
    86                                 (Cost (*)( const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment & ))
     84                        PassVisitor<CastCost_old> converter( 
     85                                dest, indexer, env, 
     86                                (Cost (*)( Type *, Type *, const SymTab::Indexer &, const TypeEnvironment & ))
    8787                                        castCost );
    8888                        src->accept( converter );
    … …  
    9696        }
    9797
    98         CastCost_old::CastCost_old( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     98        CastCost_old::CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
    9999                : ConversionCost( dest, indexer, env, costFunc ) {
    100100        }
    101101
    102         void CastCost_old::postvisit( const BasicType * basicType ) {
    103                 const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
     102        void CastCost_old::postvisit( BasicType *basicType ) {
     103                PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
    104104                if ( destAsPointer && basicType->isInteger() ) {
    105                         // necessary for, e.g. unsigned long => void *
     105                        // necessary for, e.g. unsigned long => void*
    106106                        cost = Cost::unsafe;
    107107                } else {
    … …  
    110110        }
    111111
    112         void CastCost_old::postvisit( const PointerType * pointerType ) {
    113                 if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
    114                         if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
     112        void CastCost_old::postvisit( PointerType *pointerType ) {
     113                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
     114                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
    115115                                cost = Cost::safe;
    116116                        } else {
    … …  
    125125                                } // if
    126126                        } // if
    127                 } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
     127                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
    128128                        if ( destAsBasic->isInteger() ) {
    129                                 // necessary for, e.g. void * => unsigned long
     129                                // necessary for, e.g. void* => unsigned long
    130130                                cost = Cost::unsafe;
    131131                        } // if
    … …  
    138138                using ConversionCost_new::postvisit;
    139139
    140                 CastCost_new(
    141                         const ast::Type * dst, const ast::SymbolTable & symtab,
     140                CastCost_new( 
     141                        const ast::Type * dst, const ast::SymbolTable & symtab, 
    142142                        const ast::TypeEnvironment & env, CostCalculation costFunc )
    143143                : ConversionCost_new( dst, symtab, env, costFunc ) {}
    … …  
    182182} // anonymous namespace
    183183
    184 Cost castCost(
    185         const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
    186         const ast::TypeEnvironment & env
     184Cost castCost( 
     185        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
     186        const ast::TypeEnvironment & env 
    187187) {
    188188        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    … …  
    220220                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    221221                #warning cast on ptrsCastable artifact of having two functions, remove when port done
    222                 return convertToReferenceCost(
    223                         src, refType, symtab, env,
    224                         ( int (*)(
    225                                 const ast::Type *, const ast::Type *, const ast::SymbolTable &,
     222                return convertToReferenceCost( 
     223                        src, refType, symtab, env, 
     224                        ( int (*)( 
     225                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
    226226                                const ast::TypeEnvironment & )
    227227                        ) ptrsCastable );
    … …  
    229229                #warning cast on castCost artifact of having two functions, remove when port done
    230230                ast::Pass< CastCost_new > converter{
    231                         dst, symtab, env,
    232                         ( Cost (*)(
    233                                 const ast::Type *, const ast::Type *, const ast::SymbolTable &,
     231                        dst, symtab, env, 
     232                        ( Cost (*)( 
     233                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
    234234                                const ast::TypeEnvironment & )
    235235                        ) castCost };

  • src/ResolvExpr/CommonType.cc

    rfce4e31 r302d84c2  
    3838namespace ResolvExpr {
    3939        struct CommonType_old : public WithShortCircuiting {
    40                 CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    41                 Type * get_result() const { return result; }
     40                CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
     41                Type *get_result() const { return result; }
    4242
    4343                void previsit( BaseSyntaxNode * ) { visit_children = false; }
    … …  
    6060
    6161          private:
    62                 template< typename Pointer > void getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer );
    63                 template< typename RefType > void handleRefType( RefType * inst, Type * other );
    64 
    65                 Type * result;
    66                 Type * type2;                           // inherited
     62                template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
     63                template< typename RefType > void handleRefType( RefType *inst, Type *other );
     64
     65                Type *result;
     66                Type *type2;                            // inherited
    6767                bool widenFirst, widenSecond;
    6868                const SymTab::Indexer &indexer;
    … …  
    8080                                std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
    8181                        )
    82                         if ( (widenFirst || t2->tq <= t1->tq) && (widenSecond || t1->tq <= t2->tq) ) {
     82                        if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
    8383                                PRINT(
    8484                                        std::cerr << "widen okay" << std::endl;
    8585                                )
    86                                 common->tq |= t1->tq;
    87                                 common->tq |= t2->tq;
     86                                common->get_qualifiers() |= t1->get_qualifiers();
     87                                common->get_qualifiers() |= t2->get_qualifiers();
    8888                                return common;
    8989                        }
    … …  
    9595        }
    9696
    97         Type * commonType( Type * type1, Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
     97        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
    9898                PassVisitor<CommonType_old> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
    9999
    … …  
    127127                                                std::cerr << "formal is reference; result should be reference" << std::endl;
    128128                                        )
    129                                         result = new ReferenceType( ref1->tq, result );
     129                                        result = new ReferenceType( ref1->get_qualifiers(), result );
    130130                                }
    131131                                PRINT(
    … …  
    138138
    139139                type1->accept( visitor );
    140                 Type * result = visitor.pass.get_result();
     140                Type *result = visitor.pass.get_result();
    141141                if ( ! result ) {
    142142                        // this appears to be handling for opaque type declarations
    143143                        if ( widenSecond ) {
    144                                 if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type2 ) ) {
    145                                         if ( const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() ) ) {
    146                                                 const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt );
     144                                if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
     145                                        if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
     146                                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
    147147                                                if ( type->get_base() ) {
    148                                                         Type::Qualifiers tq1 = type1->tq, tq2 = type2->tq;
     148                                                        Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
    149149                                                        AssertionSet have, need;
    150150                                                        OpenVarSet newOpen( openVars );
    151                                                         type1->tq = Type::Qualifiers();
    152                                                         type->get_base()->tq = tq1;
     151                                                        type1->get_qualifiers() = Type::Qualifiers();
     152                                                        type->get_base()->get_qualifiers() = tq1;
    153153                                                        if ( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) {
    154154                                                                result = type1->clone();
    155                                                                 result->tq = tq1 | tq2;
     155                                                                result->get_qualifiers() = tq1 | tq2;
    156156                                                        } // if
    157                                                         type1->tq = tq1;
    158                                                         type->get_base()->tq = Type::Qualifiers();
     157                                                        type1->get_qualifiers() = tq1;
     158                                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
    159159                                                } // if
    160160                                        } // if
    … …  
    190190                                 */
    191191                                  {
    192                 /*     B */                BT Bool,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
     192                /*     B*/                BT Bool,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    193193                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    194194                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    198198                                  },
    199199                                  {
    200                 /*     C */                BT Char,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
     200                /*     C*/                BT Char,                BT Char,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    201201                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    202202                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    206206                                  },
    207207                                  {
    208                 /*    SC */          BT SignedChar,          BT SignedChar,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
     208                /*    SC*/          BT SignedChar,          BT SignedChar,          BT SignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    209209                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    210210                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    214214                                  },
    215215                                  {
    216                 /*    UC */        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
     216                /*    UC*/        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,        BT UnsignedChar,      BT ShortSignedInt,    BT ShortUnsignedInt,
    217217                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    218218                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    222222                                  },
    223223                                  {
    224                 /*    SI */      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,    BT ShortUnsignedInt,
     224                /*    SI*/      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,      BT ShortSignedInt,    BT ShortUnsignedInt,
    225225                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    226226                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    230230                                  },
    231231                                  {
    232                 /*   SUI */    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,
     232                /*   SUI*/    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,    BT ShortUnsignedInt,
    233233                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    234234                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    238238                                  },
    239239                                  {
    240                 /*     I */           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,
     240                /*     I*/           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,           BT SignedInt,
    241241                                             BT SignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    242242                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    246246                                  },
    247247                                  {
    248                 /*    UI */         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,
     248                /*    UI*/         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,         BT UnsignedInt,
    249249                                           BT UnsignedInt,         BT UnsignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    250250                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    254254                                  },
    255255                                  {
    256                 /*    LI */       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,
     256                /*    LI*/       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,
    257257                                         BT LongSignedInt,       BT LongSignedInt,       BT LongSignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    258258                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    262262                                  },
    263263                                  {
    264                 /*   LUI */     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,
     264                /*   LUI*/     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,
    265265                                       BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,     BT LongUnsignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    266266                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    270270                                  },
    271271                                  {
    272                 /*   LLI */   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,
     272                /*   LLI*/   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,
    273273                                     BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt,   BT LongLongSignedInt, BT LongLongUnsignedInt,
    274274                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    278278                                  },
    279279                                  {
    280                 /*  LLUI */ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
     280                /*  LLUI*/ BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
    281281                                   BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt, BT LongLongUnsignedInt,
    282282                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    286286                                  },
    287287                                  {
    288                 /*    IB */        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
     288                /*    IB*/        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
    289289                                          BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,        BT SignedInt128,
    290290                                          BT SignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    294294                                  },
    295295                                  {
    296                 /*   UIB */      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
     296                /*   UIB*/      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
    297297                                        BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,      BT UnsignedInt128,
    298298                                        BT UnsignedInt128,      BT UnsignedInt128,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    302302                                  },
    303303                                  {
    304                 /*   _FH */            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
     304                /*   _FH*/            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
    305305                                              BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,            BT uFloat16,
    306306                                              BT uFloat16,            BT uFloat16,            BT uFloat16,     BT uFloat16Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    310310                                  },
    311311                                  {
    312                 /*   _FH */     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
     312                /*   _FH*/     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
    313313                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,
    314314                                       BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat16Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    … …  
    318318                                  },
    319319                                  {
    320                 /*    _F */            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
     320                /*    _F*/            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
    321321                                              BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,            BT uFloat32,
    322322                                              BT uFloat32,            BT uFloat32,            BT uFloat32,     BT uFloat32Complex,            BT uFloat32,     BT uFloat32Complex,
    … …  
    326326                                  },
    327327                                  {
    328                 /*   _FC */     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
     328                /*   _FC*/     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    329329                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    330330                                       BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,     BT uFloat32Complex,
    … …  
    334334                                  },
    335335                                  {
    336                 /*     F */               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
     336                /*     F*/               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
    337337                                                 BT Float,               BT Float,               BT Float,               BT Float,               BT Float,               BT Float,
    338338                                                 BT Float,               BT Float,               BT Float,        BT FloatComplex,               BT Float,        BT FloatComplex,
    … …  
    342342                                  },
    343343                                  {
    344                 /*    FC */        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
     344                /*    FC*/        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
    345345                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
    346346                                          BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,        BT FloatComplex,
    … …  
    350350                                  },
    351351                                  {
    352                 /*   _FX */           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
     352                /*   _FX*/           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
    353353                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,           BT uFloat32x,
    354354                                             BT uFloat32x,           BT uFloat32x,           BT uFloat32x,    BT uFloat32xComplex,           BT uFloat32x,    BT uFloat32xComplex,
    … …  
    358358                                  },
    359359                                  {
    360                 /*  _FXC */    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
     360                /*  _FXC*/    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    361361                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    362362                                      BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,    BT uFloat32xComplex,
    … …  
    366366                                  },
    367367                                  {
    368                 /*    FD */            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
     368                /*    FD*/            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
    369369                                              BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,            BT uFloat64,
    370370                                              BT uFloat64,            BT uFloat64,            BT uFloat64,     BT uFloat64Complex,            BT uFloat64,     BT uFloat64Complex,
    … …  
    374374                                  },
    375375                                  {
    376                 /*  _FDC */     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
     376                /*  _FDC*/     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    377377                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    378378                                       BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,     BT uFloat64Complex,
    … …  
    382382                                  },
    383383                                  {
    384                 /*     D */              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
     384                /*     D*/              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
    385385                                                BT Double,              BT Double,              BT Double,              BT Double,              BT Double,              BT Double,
    386386                                                BT Double,              BT Double,              BT Double,       BT DoubleComplex,              BT Double,       BT DoubleComplex,
    … …  
    390390                                  },
    391391                                  {
    392                 /*    DC */       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
     392                /*    DC*/       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
    393393                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
    394394                                         BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,       BT DoubleComplex,
    … …  
    398398                                  },
    399399                                  {
    400                 /*  F80X */           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
     400                /*  F80X*/           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
    401401                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,           BT uFloat64x,
    402402                                             BT uFloat64x,           BT uFloat64x,           BT uFloat64x,    BT uFloat64xComplex,           BT uFloat64x,    BT uFloat64xComplex,
    … …  
    406406                                  },
    407407                                  {
    408                 /* _FDXC */    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
     408                /* _FDXC*/    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    409409                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    410410                                      BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,    BT uFloat64xComplex,
    … …  
    422422                                  },
    423423                                  {
    424                 /*   _FB */           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
     424                /*   _FB*/           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
    425425                                             BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,           BT uFloat128,
    426426                                             BT uFloat128,           BT uFloat128,           BT uFloat128,    BT uFloat128Complex,           BT uFloat128,    BT uFloat128Complex,
    … …  
    430430                                  },
    431431                                  {
    432                 /* _FLDC */    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
     432                /* _FLDC*/    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    433433                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    434434                                      BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,    BT uFloat128Complex,
    … …  
    438438                                  },
    439439                                  {
    440                 /*    FB */          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
     440                /*    FB*/          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
    441441                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,          BT uuFloat128,
    442442                                            BT uuFloat128,          BT uuFloat128,          BT uuFloat128,    BT uFloat128Complex,          BT uuFloat128,    BT uFloat128Complex,
    … …  
    446446                                  },
    447447                                  {
    448                 /*    LD */          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
     448                /*    LD*/          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
    449449                                            BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,          BT LongDouble,
    450450                                            BT LongDouble,          BT LongDouble,          BT LongDouble,   BT LongDoubleComplex,          BT LongDouble,   BT LongDoubleComplex,
    … …  
    454454                                  },
    455455                                  {
    456                 /*   LDC */   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
     456                /*   LDC*/   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
    457457                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
    458458                                     BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,   BT LongDoubleComplex,
    … …  
    462462                                  },
    463463                                  {
    464                 /*  _FBX */          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
     464                /*  _FBX*/          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
    465465                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,          BT uFloat128x,
    466466                                            BT uFloat128x,          BT uFloat128x,          BT uFloat128x,   BT uFloat128xComplex,          BT uFloat128x,   BT uFloat128xComplex,
    … …  
    470470                                  },
    471471                                  {
    472                 /* _FLDXC */   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
     472                /*_FLDXC*/   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    473473                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    474474                                     BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,   BT uFloat128xComplex,
    … …  
    481481        // GENERATED END
    482482        static_assert(
    483                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
     483                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    484484                "Each basic type kind should have a corresponding row in the combined type matrix"
    485485        );
    486486
    487         CommonType_old::CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
     487        CommonType_old::CommonType_old( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
    488488                : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) {
    489489        }
    … …  
    491491        void CommonType_old::postvisit( VoidType * ) {}
    492492
    493         void CommonType_old::postvisit( BasicType * basicType ) {
    494                 if ( BasicType * otherBasic = dynamic_cast< BasicType * >( type2 ) ) {
     493        void CommonType_old::postvisit( BasicType *basicType ) {
     494                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    495495                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
    496                         if ( ( ( newType == basicType->get_kind() && basicType->tq >= otherBasic->tq ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->tq <= otherBasic->tq ) || widenSecond ) ) {
    497                                 result = new BasicType( basicType->tq | otherBasic->tq, newType );
     496                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
     497                                result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
    498498                        } // if
    499                 } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
     499                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    500500                        // use signed int in lieu of the enum/zero/one type
    501501                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
    502                         if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) {
    503                                 result = new BasicType( basicType->tq | type2->tq, newType );
     502                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
     503                                result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );
    504504                        } // if
    505505                } // if
    … …  
    507507
    508508        template< typename Pointer >
    509         void CommonType_old::getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer ) {
    510                 if ( TypeInstType * var = dynamic_cast< TypeInstType * >( otherPointer->get_base() ) ) {
     509        void CommonType_old::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
     510                if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) {
    511511                        OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
    512512                        if ( entry != openVars.end() ) {
    … …  
    517517                }
    518518                result = voidPointer->clone();
    519                 result->tq |= otherPointer->tq;
    520         }
    521 
    522         void CommonType_old::postvisit( PointerType * pointerType ) {
    523                 if ( PointerType * otherPointer = dynamic_cast< PointerType * >( type2 ) ) {
     519                result->get_qualifiers() |= otherPointer->get_qualifiers();
     520        }
     521
     522        void CommonType_old::postvisit( PointerType *pointerType ) {
     523                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
    524524                        // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
    525                         if ( widenFirst && dynamic_cast< VoidType * >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
     525                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
    526526                                getCommonWithVoidPointer( otherPointer, pointerType );
    527                         } else if ( widenSecond && dynamic_cast< VoidType * >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
     527                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
    528528                                getCommonWithVoidPointer( pointerType, otherPointer );
    529                         } else if ( ( pointerType->get_base()->tq >= otherPointer->get_base()->tq || widenFirst )
    530                                            && ( pointerType->get_base()->tq <= otherPointer->get_base()->tq || widenSecond ) ) {
     529                        } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
     530                                           && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) {
    531531                                // std::cerr << "middle case" << std::endl;
    532                                 Type::Qualifiers tq1 = pointerType->get_base()->tq, tq2 = otherPointer->get_base()->tq;
    533                                 pointerType->get_base()->tq = Type::Qualifiers();
    534                                 otherPointer->get_base()->tq = Type::Qualifiers();
     532                                Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers();
     533                                pointerType->get_base()->get_qualifiers() = Type::Qualifiers();
     534                                otherPointer->get_base()->get_qualifiers() = Type::Qualifiers();
    535535                                AssertionSet have, need;
    536536                                OpenVarSet newOpen( openVars );
    … …  
    542542                                                result = otherPointer->clone();
    543543                                        } // if
    544                                         strict_dynamic_cast<PointerType *>(result)->base->tq = tq1 | tq2;
     544                                        strict_dynamic_cast<PointerType*>(result)->base->get_qualifiers() = tq1 | tq2;
    545545                                } else {
    546546                                        /// std::cerr << "place for ptr-to-type" << std::endl;
    547547                                } // if
    548                                 pointerType->get_base()->tq = tq1;
    549                                 otherPointer->get_base()->tq = tq2;
     548                                pointerType->get_base()->get_qualifiers() = tq1;
     549                                otherPointer->get_base()->get_qualifiers() = tq2;
    550550                        } // if
    551                 } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
     551                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
    552552                        result = pointerType->clone();
    553                         result->tq |= type2->tq;
     553                        result->get_qualifiers() |= type2->get_qualifiers();
    554554                } // if
    555555        }
    … …  
    557557        void CommonType_old::postvisit( ArrayType * ) {}
    558558
    559         void CommonType_old::postvisit( ReferenceType * refType ) {
    560                 if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( type2 ) ) {
     559        void CommonType_old::postvisit( ReferenceType *refType ) {
     560                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
    561561                        // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
    562                         // std::cerr << ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst ) << (refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond) << std::endl;
    563                         if ( widenFirst && dynamic_cast< VoidType * >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
     562                        // std::cerr << ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) << (refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond) << std::endl;
     563                        if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
    564564                                getCommonWithVoidPointer( otherRef, refType );
    565                         } else if ( widenSecond && dynamic_cast< VoidType * >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
     565                        } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
    566566                                getCommonWithVoidPointer( refType, otherRef );
    567                         } else if ( ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst )
    568                                            && ( refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond ) ) {
     567                        } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst )
     568                                           && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) {
    569569                                // std::cerr << "middle case" << std::endl;
    570                                 Type::Qualifiers tq1 = refType->get_base()->tq, tq2 = otherRef->get_base()->tq;
    571                                 refType->get_base()->tq = Type::Qualifiers();
    572                                 otherRef->get_base()->tq = Type::Qualifiers();
     570                                Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers();
     571                                refType->get_base()->get_qualifiers() = Type::Qualifiers();
     572                                otherRef->get_base()->get_qualifiers() = Type::Qualifiers();
    573573                                AssertionSet have, need;
    574574                                OpenVarSet newOpen( openVars );
    … …  
    579579                                                result = otherRef->clone();
    580580                                        } // if
    581                                         strict_dynamic_cast<ReferenceType *>(result)->base->tq = tq1 | tq2;
     581                                        strict_dynamic_cast<ReferenceType*>(result)->base->get_qualifiers() = tq1 | tq2;
    582582                                } else {
    583583                                        /// std::cerr << "place for ptr-to-type" << std::endl;
    584584                                } // if
    585                                 refType->get_base()->tq = tq1;
    586                                 otherRef->get_base()->tq = tq2;
     585                                refType->get_base()->get_qualifiers() = tq1;
     586                                otherRef->get_base()->get_qualifiers() = tq2;
    587587                        } // if
    588                 } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
     588                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
    589589                        result = refType->clone();
    590                         result->tq |= type2->tq;
     590                        result->get_qualifiers() |= type2->get_qualifiers();
    591591                } // if
    592592        }
    … …  
    596596        void CommonType_old::postvisit( UnionInstType * ) {}
    597597
    598         void CommonType_old::postvisit( EnumInstType * enumInstType ) {
    599                 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
     598        void CommonType_old::postvisit( EnumInstType *enumInstType ) {
     599                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    600600                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
    601601                        result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars );
    … …  
    606606        }
    607607
    608         void CommonType_old::postvisit( TypeInstType * inst ) {
     608        void CommonType_old::postvisit( TypeInstType *inst ) {
    609609                if ( widenFirst ) {
    610                         const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() );
     610                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
    611611                        if ( nt ) {
    612                                 const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt );
     612                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
    613613                                if ( type->get_base() ) {
    614                                         Type::Qualifiers tq1 = inst->tq, tq2 = type2->tq;
     614                                        Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
    615615                                        AssertionSet have, need;
    616616                                        OpenVarSet newOpen( openVars );
    617                                         type2->tq = Type::Qualifiers();
    618                                         type->get_base()->tq = tq1;
     617                                        type2->get_qualifiers() = Type::Qualifiers();
     618                                        type->get_base()->get_qualifiers() = tq1;
    619619                                        if ( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) {
    620620                                                result = type2->clone();
    621                                                 result->tq = tq1 | tq2;
     621                                                result->get_qualifiers() = tq1 | tq2;
    622622                                        } // if
    623                                         type2->tq = tq2;
    624                                         type->get_base()->tq = Type::Qualifiers();
     623                                        type2->get_qualifiers() = tq2;
     624                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
    625625                                } // if
    626626                        } // if
    … …  
    631631        void CommonType_old::postvisit( VarArgsType * ) {}
    632632
    633         void CommonType_old::postvisit( ZeroType * zeroType ) {
     633        void CommonType_old::postvisit( ZeroType *zeroType ) {
    634634                if ( widenFirst ) {
    635                         if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< PointerType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) {
    636                                 if ( widenSecond || zeroType->tq <= type2->tq ) {
     635                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
     636                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
    637637                                        result = type2->clone();
    638                                         result->tq |= zeroType->tq;
    639                                 }
    640                         } else if ( widenSecond && dynamic_cast< OneType * >( type2 ) ) {
    641                                 result = new BasicType( zeroType->tq, BasicType::SignedInt );
    642                                 result->tq |= type2->tq;
    643                         }
    644                 }
    645         }
    646 
    647         void CommonType_old::postvisit( OneType * oneType ) {
     638                                        result->get_qualifiers() |= zeroType->get_qualifiers();
     639                                }
     640                        } else if ( widenSecond && dynamic_cast< OneType* >( type2 ) ) {
     641                                result = new BasicType( zeroType->get_qualifiers(), BasicType::SignedInt );
     642                                result->get_qualifiers() |= type2->get_qualifiers();
     643                        }
     644                }
     645        }
     646
     647        void CommonType_old::postvisit( OneType *oneType ) {
    648648                if ( widenFirst ) {
    649                         if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) {
    650                                 if ( widenSecond || oneType->tq <= type2->tq ) {
     649                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
     650                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
    651651                                        result = type2->clone();
    652                                         result->tq |= oneType->tq;
    653                                 }
    654                         } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
    655                                 result = new BasicType( oneType->tq, BasicType::SignedInt );
    656                                 result->tq |= type2->tq;
     652                                        result->get_qualifiers() |= oneType->get_qualifiers();
     653                                }
     654                        } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
     655                                result = new BasicType( oneType->get_qualifiers(), BasicType::SignedInt );
     656                                result->get_qualifiers() |= type2->get_qualifiers();
    657657                        }
    658658                }
    … …  
    668668                ast::ptr< ast::Type > result;
    669669
    670                 CommonType_new(
    671                         const ast::Type * t2, WidenMode w, const ast::SymbolTable & st,
     670                CommonType_new( 
     671                        const ast::Type * t2, WidenMode w, const ast::SymbolTable & st, 
    672672                        ast::TypeEnvironment & env, const ast::OpenVarSet & o )
    673673                : type2( t2 ), widen( w ), symtab( st ), tenv( env ), open( o ), result() {}
    … …  
    681681                                #warning remove casts when `commonTypes` moved to new AST
    682682                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
    683                                 if (
    684                                         ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers )
    685                                                 || widen.first )
    686                                         && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers )
    687                                                 || widen.second )
     683                                if ( 
     684                                        ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers ) 
     685                                                || widen.first ) 
     686                                        && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers ) 
     687                                                || widen.second ) 
    688688                                ) {
    689689                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
    690690                                }
    691                         } else if (
    692                                 dynamic_cast< const ast::EnumInstType * >( type2 )
     691                        } else if ( 
     692                                dynamic_cast< const ast::EnumInstType * >( type2 ) 
    693693                                || dynamic_cast< const ast::ZeroType * >( type2 )
    694694                                || dynamic_cast< const ast::OneType * >( type2 )
    … …  
    696696                                #warning remove casts when `commonTypes` moved to new AST
    697697                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
    698                                 if (
    699                                         ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
    700                                                 || widen.first )
    701                                         && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
    702                                                 || widen.second )
     698                                if ( 
     699                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers ) 
     700                                                || widen.first ) 
     701                                        && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers ) 
     702                                                || widen.second ) 
    703703                                ) {
    704704                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
    … …  
    715715                                if ( entry != open.end() ) {
    716716                                        ast::AssertionSet need, have;
    717                                         if ( ! tenv.bindVar(
    718                                                 var, voidPtr->base, entry->second, need, have, open, widen, symtab )
     717                                        if ( ! tenv.bindVar( 
     718                                                var, voidPtr->base, entry->second, need, have, open, widen, symtab ) 
    719719                                        ) return;
    720720                                }
    … …  
    727727                void postvisit( const ast::PointerType * pointer ) {
    728728                        if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
    729                                 if (
    730                                         widen.first
    731                                         && pointer2->base.as< ast::VoidType >()
    732                                         && ! ast::isFtype( pointer->base )
     729                                if ( 
     730                                        widen.first 
     731                                        && pointer2->base.as< ast::VoidType >() 
     732                                        && ! ast::isFtype( pointer->base ) 
    733733                                ) {
    734734                                        getCommonWithVoidPointer( pointer2, pointer );
    735                                 } else if (
    736                                         widen.second
    737                                         && pointer->base.as< ast::VoidType >()
    738                                         && ! ast::isFtype( pointer2->base )
     735                                } else if ( 
     736                                        widen.second 
     737                                        && pointer->base.as< ast::VoidType >() 
     738                                        && ! ast::isFtype( pointer2->base ) 
    739739                                ) {
    740740                                        getCommonWithVoidPointer( pointer, pointer2 );
    … …  
    746746                                        ast::CV::Qualifiers q2 = pointer2->base->qualifiers;
    747747
    748                                         // force t{1,2} to be cloned if their qualifiers must be stripped, so that
     748                                        // force t{1,2} to be cloned if their qualifiers must be stripped, so that 
    749749                                        // pointer{,2}->base are unchanged
    750750                                        ast::ptr< ast::Type > t1{ pointer->base }, t2{ pointer2->base };
    751751                                        reset_qualifiers( t1 );
    752752                                        reset_qualifiers( t2 );
    753 
     753                                       
    754754                                        ast::AssertionSet have, need;
    755755                                        ast::OpenVarSet newOpen{ open };
    … …  
    758758                                                if ( q1.val != q2.val ) {
    759759                                                        // reset result->base->qualifiers to be union of two base qualifiers
    760                                                         strict_dynamic_cast< ast::PointerType * >(
    761                                                                 result.get_and_mutate()
     760                                                        strict_dynamic_cast< ast::PointerType * >( 
     761                                                                result.get_and_mutate() 
    762762                                                        )->base.get_and_mutate()->qualifiers = q1 | q2;
    763763                                                }
    … …  
    775775                        if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
    776776                                if (
    777                                         widen.first && ref2->base.as< ast::VoidType >() && ! ast::isFtype( ref->base )
     777                                        widen.first && ref2->base.as< ast::VoidType >() && ! ast::isFtype( ref->base ) 
    778778                                ) {
    779779                                        getCommonWithVoidPointer( ref2, ref );
    780                                 } else if (
    781                                         widen.second && ref->base.as< ast::VoidType>() && ! ast::isFtype( ref2->base )
     780                                } else if ( 
     781                                        widen.second && ref->base.as< ast::VoidType>() && ! ast::isFtype( ref2->base ) 
    782782                                ) {
    783783                                        getCommonWithVoidPointer( ref, ref2 );
    … …  
    788788                                        ast::CV::Qualifiers q1 = ref->base->qualifiers, q2 = ref2->base->qualifiers;
    789789
    790                                         // force t{1,2} to be cloned if their qualifiers must be stripped, so that
     790                                        // force t{1,2} to be cloned if their qualifiers must be stripped, so that 
    791791                                        // ref{,2}->base are unchanged
    792792                                        ast::ptr< ast::Type > t1{ ref->base }, t2{ ref2->base };
    … …  
    800800                                                if ( q1.val != q2.val ) {
    801801                                                        // reset result->base->qualifiers to be union of two base qualifiers
    802                                                         strict_dynamic_cast< ast::ReferenceType * >(
    803                                                                 result.get_and_mutate()
     802                                                        strict_dynamic_cast< ast::ReferenceType * >( 
     803                                                                result.get_and_mutate() 
    804804                                                        )->base.get_and_mutate()->qualifiers = q1 | q2;
    805805                                                }
    … …  
    819819
    820820                void postvisit( const ast::EnumInstType * enumInst ) {
    821                         if (
    822                                 dynamic_cast< const ast::BasicType * >( type2 )
     821                        if ( 
     822                                dynamic_cast< const ast::BasicType * >( type2 ) 
    823823                                || dynamic_cast< const ast::ZeroType * >( type2 )
    824824                                || dynamic_cast< const ast::OneType * >( type2 )
    … …  
    834834                        if ( ! widen.first ) return;
    835835                        if ( const ast::NamedTypeDecl * nt = symtab.lookupType( inst->name ) ) {
    836                                 if ( const ast::Type * base =
    837                                                 strict_dynamic_cast< const ast::TypeDecl * >( nt )->base
     836                                if ( const ast::Type * base = 
     837                                                strict_dynamic_cast< const ast::TypeDecl * >( nt )->base 
    838838                                ) {
    839839                                        ast::CV::Qualifiers q1 = inst->qualifiers, q2 = type2->qualifiers;
    … …  
    860860                void postvisit( const ast::ZeroType * zero ) {
    861861                        if ( ! widen.first ) return;
    862                         if (
     862                        if ( 
    863863                                dynamic_cast< const ast::BasicType * >( type2 )
    864864                                || dynamic_cast< const ast::PointerType * >( type2 )
    … …  
    870870                                }
    871871                        } else if ( widen.second && dynamic_cast< const ast::OneType * >( type2 ) ) {
    872                                 result = new ast::BasicType{
     872                                result = new ast::BasicType{ 
    873873                                        ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
    874874                        }
    … …  
    877877                void postvisit( const ast::OneType * one ) {
    878878                        if ( ! widen.first ) return;
    879                         if (
     879                        if ( 
    880880                                dynamic_cast< const ast::BasicType * >( type2 )
    881881                                || dynamic_cast< const ast::EnumInstType * >( type2 )
    … …  
    886886                                }
    887887                        } else if ( widen.second && dynamic_cast< const ast::ZeroType * >( type2 ) ) {
    888                                 result = new ast::BasicType{
     888                                result = new ast::BasicType{ 
    889889                                        ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
    890890                        }
    … …  
    894894
    895895        namespace {
    896                 ast::ptr< ast::Type > handleReference(
    897                         const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen,
    898                         const ast::SymbolTable & symtab, ast::TypeEnvironment & env,
    899                         const ast::OpenVarSet & open
     896                ast::ptr< ast::Type > handleReference( 
     897                        const ast::ptr< ast::Type > & t1, const ast::ptr< ast::Type > & t2, WidenMode widen, 
     898                        const ast::SymbolTable & symtab, ast::TypeEnvironment & env, 
     899                        const ast::OpenVarSet & open 
    900900                ) {
    901901                        ast::ptr<ast::Type> common;
    … …  
    926926
    927927        ast::ptr< ast::Type > commonType(
    928                         const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,
    929                         WidenMode widen, const ast::SymbolTable & symtab, ast::TypeEnvironment & env,
    930                         const ast::OpenVarSet & open
     928                        const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, 
     929                        WidenMode widen, const ast::SymbolTable & symtab, ast::TypeEnvironment & env, 
     930                        const ast::OpenVarSet & open 
    931931        ) {
    932932                unsigned depth1 = type1->referenceDepth();
    … …  
    940940                        const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >();
    941941                        const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >();
    942 
     942                       
    943943                        if ( depth1 > depth2 ) {
    944944                                assert( ref1 );
    … …  
    978978                                                ast::OpenVarSet newOpen{ open };
    979979
    980                                                 // force t{1,2} to be cloned if its qualifiers must be stripped, so that
    981                                                 // type1 and type->base are left unchanged; calling convention forces
     980                                                // force t{1,2} to be cloned if its qualifiers must be stripped, so that 
     981                                                // type1 and type->base are left unchanged; calling convention forces 
    982982                                                // {type1,type->base}->strong_ref >= 1
    983983                                                ast::ptr<ast::Type> t1{ type1 }, t2{ type->base };
    984984                                                reset_qualifiers( t1 );
    985985                                                reset_qualifiers( t2, q1 );
    986 
     986                                               
    987987                                                if ( unifyExact( t1, t2, env, have, need, newOpen, noWiden(), symtab ) ) {
    988988                                                        result = t1;

  • src/ResolvExpr/ConversionCost.cc

    rfce4e31 r302d84c2  
    4646#endif
    4747
    48         Cost conversionCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    49                 if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
     48        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     49                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    5050                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    51                         if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
     51                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
    5252                                if ( eqvClass->type ) {
    5353                                        return conversionCost( src, eqvClass->type, indexer, env );
    … …  
    5555                                        return Cost::infinity;
    5656                                }
    57                         } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
     57                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
    5858                                PRINT( std::cerr << " found" << std::endl; )
    59                                 const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
     59                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    6060                                // all typedefs should be gone by this point
    6161                                assert( type );
    … …  
    7777                        PRINT( std::cerr << "compatible!" << std::endl; )
    7878                        return Cost::zero;
    79                 } else if ( dynamic_cast< const VoidType * >( dest ) ) {
     79                } else if ( dynamic_cast< VoidType* >( dest ) ) {
    8080                        return Cost::safe;
    81                 } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
     81                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    8282                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    83                         return convertToReferenceCost( src, refType, indexer, env, [](const Type * const t1, const Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
     83                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
    8484                                return ptrsAssignable( t1, t2, env );
    8585                        });
    8686                } else {
    87                         PassVisitor<ConversionCost> converter(
    88                                 dest, indexer, env,
    89                                 (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&))
     87                        PassVisitor<ConversionCost> converter( 
     88                                dest, indexer, env, 
     89                                (Cost (*)(Type*, Type*, const SymTab::Indexer&, const TypeEnvironment&))
    9090                                        conversionCost );
    9191                        src->accept( converter );
    … …  
    9898        }
    9999
    100         Cost convertToReferenceCost( const Type * src, const Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     100        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    101101                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
    102102                if ( diff > 0 ) {
    103103                        // TODO: document this
    104                         Cost cost = convertToReferenceCost( strict_dynamic_cast< const ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
     104                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
    105105                        cost.incReference();
    106106                        return cost;
    107107                } else if ( diff < -1 ) {
    108108                        // TODO: document this
    109                         Cost cost = convertToReferenceCost( src, strict_dynamic_cast< const ReferenceType * >( dest )->base, diff+1, indexer, env, func );
     109                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
    110110                        cost.incReference();
    111111                        return cost;
    112112                } else if ( diff == 0 ) {
    113                         const ReferenceType * srcAsRef = dynamic_cast< const ReferenceType * >( src );
    114                         const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
     113                        ReferenceType * srcAsRef = dynamic_cast< ReferenceType * >( src );
     114                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
    115115                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
    116116                                PRINT( std::cerr << "converting between references" << std::endl; )
    117                                 Type::Qualifiers tq1 = srcAsRef->base->tq;
    118                                 Type::Qualifiers tq2 = destAsRef->base->tq;
     117                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
     118                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
    119119                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
    120120                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    … …  
    137137                        } else {
    138138                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
    139                                 PassVisitor<ConversionCost> converter(
    140                                         dest, indexer, env,
    141                                         (Cost (*)(const Type *, const Type *, const SymTab::Indexer&, const TypeEnvironment&))
     139                                PassVisitor<ConversionCost> converter( 
     140                                        dest, indexer, env, 
     141                                        (Cost (*)(Type*, Type*, const SymTab::Indexer&, const TypeEnvironment&))
    142142                                                conversionCost );
    143143                                src->accept( converter );
    … …  
    145145                        } // if
    146146                } else {
    147                         const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
     147                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
    148148                        assert( diff == -1 && destAsRef );
    149149                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
    … …  
    156156                                        )
    157157                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
    158                                         if ( src->tq == destAsRef->base->tq ) {
     158                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
    159159                                                return Cost::reference; // cost needs to be non-zero to add cast
    160                                         } if ( src->tq < destAsRef->base->tq ) {
     160                                        } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
    161161                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
    162162                                        } else {
    … …  
    178178        }
    179179
    180         Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
     180        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    181181                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
    182182                Cost cost = convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env, func );
    … …  
    185185        }
    186186
    187         ConversionCost::ConversionCost( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     187        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
    188188                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
    189189        }
    … …  
    193193        /* EXTENDED INTEGRAL RANK HIERARCHY (root to leaves)
    194194                                 _Bool
    195         char                signed char         unsigned char
    196                   signed short int         unsigned short int
    197                   signed int               unsigned int
    198                   signed long int          unsigned long int
    199                   signed long long int     unsigned long long int
    200                   __int128                 unsigned __int128
    201                   _Float16                 _Float16 _Complex
    202                   _Float32                 _Float32 _Complex
    203                   float                    float _Complex
    204                   _Float32x                _Float32x _Complex
    205                   _Float64                 _Float64 _Complex
    206                   double                   double _Complex
    207                   _Float64x                _Float64x _Complex
     195        char                signed char         unsigned char       
     196                  signed short int         unsigned short int       
     197                  signed int               unsigned int             
     198                  signed long int          unsigned long int       
     199                  signed long long int     unsigned long long int   
     200                  __int128                 unsigned __int128       
     201                  _Float16                 _Float16 _Complex       
     202                  _Float32                 _Float32 _Complex       
     203                  float                    float _Complex           
     204                  _Float32x                _Float32x _Complex       
     205                  _Float64                 _Float64 _Complex       
     206                  double                   double _Complex         
     207                  _Float64x                _Float64x _Complex       
    208208                             __float80
    209                   _Float128                _Float128 _Complex
     209                  _Float128                _Float128 _Complex       
    210210                            __float128
    211                   long double              long double _Complex
    212                   _Float128x               _Float128x _Complex
     211                  long double              long double _Complex     
     212                  _Float128x               _Float128x _Complex     
    213213        */
    214214        // GENERATED END
    … …  
    218218        static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
    219219                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
    220                 /*     B */ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
    221                 /*     C */ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
    222                 /*    SC */ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
    223                 /*    UC */ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
    224                 /*    SI */ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
    225                 /*   SUI */ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
    226                 /*     I */ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
    227                 /*    UI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
    228                 /*    LI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
    229                 /*   LUI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
    230                 /*   LLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
    231                 /*  LLUI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
    232                 /*    IB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
    233                 /*   UIB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
    234                 /*   _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,  10,   9,  11,  10, },
    235                 /*   _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,   6,  -1,  -1,   7,  -1,  -1,   8,  -1,   9, },
    236                 /*    _F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,   8,  10,   9, },
    237                 /*   _FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,  -1,   6,  -1,  -1,   7,  -1,   8, },
    238                 /*     F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   7,   9,   8, },
    239                 /*    FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,  -1,   5,  -1,  -1,   6,  -1,   7, },
    240                 /*   _FX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   6,   8,   7, },
    241                 /*  _FXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,  -1,   4,  -1,  -1,   5,  -1,   6, },
    242                 /*    FD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   5,   7,   6, },
    243                 /*  _FDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,  -1,   3,  -1,  -1,   4,  -1,   5, },
    244                 /*     D */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   4,   6,   5, },
    245                 /*    DC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,  -1,   2,  -1,  -1,   3,  -1,   4, },
    246                 /*  F80X */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   3,   5,   4, },
    247                 /* _FDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,  -1,   2,  -1,   3, },
     220                /*     B*/ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
     221                /*     C*/ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
     222                /*    SC*/ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
     223                /*    UC*/ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  15,  17,  16, },
     224                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
     225                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  14,  16,  15, },
     226                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
     227                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  13,  15,  14, },
     228                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
     229                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  12,  14,  13, },
     230                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
     231                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  11,  13,  12, },
     232                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
     233                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  10,  12,  11, },
     234                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,  10,   9,  11,  10, },
     235                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,   6,  -1,  -1,   7,  -1,  -1,   8,  -1,   9, },
     236                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,   8,  10,   9, },
     237                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,  -1,   6,  -1,  -1,   7,  -1,   8, },
     238                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   7,   9,   8, },
     239                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,  -1,   5,  -1,  -1,   6,  -1,   7, },
     240                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   6,   8,   7, },
     241                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,  -1,   4,  -1,  -1,   5,  -1,   6, },
     242                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   5,   7,   6, },
     243                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,  -1,   3,  -1,  -1,   4,  -1,   5, },
     244                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   4,   6,   5, },
     245                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,  -1,   2,  -1,  -1,   3,  -1,   4, },
     246                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   3,   5,   4, },
     247                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,  -1,   2,  -1,   3, },
    248248                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3,   3,   4,   4, },
    249                 /*   _FB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3, },
    250                 /* _FLDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,   2, },
    251                 /*    FB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3, },
    252                 /*    LD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2, },
    253                 /*   LDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1, },
    254                 /*  _FBX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1, },
    255                 /* _FLDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
     249                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3, },
     250                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   1,  -1,   2, },
     251                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,   0,   1,   2,   2,   3, },
     252                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2, },
     253                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1, },
     254                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1, },
     255                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
    256256        }; // costMatrix
    257257        static const int maxIntCost = 15;
    258258        // GENERATED END
    259259        static_assert(
    260                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
     260                sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    261261                "Missing row in the cost matrix"
    262262        );
    … …  
    266266        static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
    267267                /*             B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
    268                 /*     B */ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    269                 /*     C */ {  -1,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    270                 /*    SC */ {  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    271                 /*    UC */ {  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    272                 /*    SI */ {  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    273                 /*   SUI */ {  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    274                 /*     I */ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    275                 /*    UI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    276                 /*    LI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    277                 /*   LUI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    278                 /*   LLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    279                 /*  LLUI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    280                 /*    IB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    281                 /*   UIB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    282                 /*   _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    283                 /*   _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    284                 /*    _F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    285                 /*   _FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    286                 /*     F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    287                 /*    FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    288                 /*   _FX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    289                 /*  _FXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    290                 /*    FD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    291                 /*  _FDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    292                 /*     D */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    293                 /*    DC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    294                 /*  F80X */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    295                 /* _FDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     268                /*     B*/ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     269                /*     C*/ {  -1,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     270                /*    SC*/ {  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     271                /*    UC*/ {  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     272                /*    SI*/ {  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     273                /*   SUI*/ {  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     274                /*     I*/ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     275                /*    UI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     276                /*    LI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     277                /*   LUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     278                /*   LLI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     279                /*  LLUI*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     280                /*    IB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     281                /*   UIB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     282                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     283                /*   _FH*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     284                /*    _F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     285                /*   _FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     286                /*     F*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     287                /*    FC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     288                /*   _FX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     289                /*  _FXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     290                /*    FD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     291                /*  _FDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     292                /*     D*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     293                /*    DC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     294                /*  F80X*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
     295                /* _FDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    296296                /*   F80*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
    297                 /*   _FB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0, },
    298                 /* _FLDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
    299                 /*    FB */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0, },
    300                 /*    LD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0, },
    301                 /*   LDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0, },
    302                 /*  _FBX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0, },
    303                 /* _FLDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
     297                /*   _FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0,   0, },
     298                /* _FLDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   0,  -1,   0, },
     299                /*    FB*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0,   0,   0, },
     300                /*    LD*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0,   0,   0, },
     301                /*   LDC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   0, },
     302                /*  _FBX*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   0, },
     303                /*_FLDXC*/ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
    304304        }; // signMatrix
    305305        // GENERATED END
    306306        static_assert(
    307                 sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
     307                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES*BasicType::NUMBER_OF_BASIC_TYPES,
    308308                "Missing row in the sign matrix"
    309309        );
    310310
    311         void ConversionCost::postvisit( const VoidType * ) {
     311        void ConversionCost::postvisit( VoidType * ) {
    312312                cost = Cost::infinity;
    313313        }
    314314
    315         void ConversionCost::postvisit(const BasicType * basicType) {
    316                 if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
    317                         int tableResult = costMatrix[ basicType->kind ][ destAsBasic->kind ];
     315        void ConversionCost::postvisit(BasicType *basicType) {
     316                if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
     317                        int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
    318318                        if ( tableResult == -1 ) {
    319319                                cost = Cost::unsafe;
    … …  
    321321                                cost = Cost::zero;
    322322                                cost.incSafe( tableResult );
    323                                 cost.incSign( signMatrix[ basicType->kind ][ destAsBasic->kind ] );
    324                         } // if
    325                 } else if ( dynamic_cast< const EnumInstType * >( dest ) ) {
     323                                cost.incSign( signMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ] );
     324                        } // if
     325                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
    326326                        // xxx - not positive this is correct, but appears to allow casting int => enum
    327327                        cost = Cost::unsafe;
    … …  
    330330        }
    331331
    332         void ConversionCost::postvisit( const PointerType * pointerType ) {
    333                 if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
     332        void ConversionCost::postvisit( PointerType * pointerType ) {
     333                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    334334                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
    335                         Type::Qualifiers tq1 = pointerType->base->tq;
    336                         Type::Qualifiers tq2 = destAsPtr->base->tq;
     335                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
     336                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
    337337                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
    338338                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    … …  
    363363        }
    364364
    365         void ConversionCost::postvisit( const ArrayType * ) {}
    366 
    367         void ConversionCost::postvisit( const ReferenceType * refType ) {
     365        void ConversionCost::postvisit( ArrayType * ) {}
     366
     367        void ConversionCost::postvisit( ReferenceType * refType ) {
    368368                // Note: dest can never be a reference, since it would have been caught in an earlier check
    369                 assert( ! dynamic_cast< const ReferenceType * >( dest ) );
     369                assert( ! dynamic_cast< ReferenceType * >( dest ) );
    370370                // convert reference to rvalue: cv T1 & => T2
    371371                // recursively compute conversion cost from T1 to T2.
    372372                // cv can be safely dropped because of 'implicit dereference' behavior.
    373373                cost = costFunc( refType->base, dest, indexer, env );
    374                 if ( refType->base->tq == dest->tq ) {
     374                if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
    375375                        cost.incReference();  // prefer exact qualifiers
    376                 } else if ( refType->base->tq < dest->tq ) {
     376                } else if ( refType->base->get_qualifiers() < dest->get_qualifiers() ) {
    377377                        cost.incSafe(); // then gaining qualifiers
    378378                } else {
    … …  
    382382        }
    383383
    384         void ConversionCost::postvisit( const FunctionType * ) {}
    385 
    386         void ConversionCost::postvisit( const StructInstType * inst ) {
    387                 if ( const StructInstType * destAsInst = dynamic_cast< const StructInstType * >( dest ) ) {
     384        void ConversionCost::postvisit( FunctionType * ) {}
     385
     386        void ConversionCost::postvisit( StructInstType * inst ) {
     387                if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
    388388                        if ( inst->name == destAsInst->name ) {
    389389                                cost = Cost::zero;
    … …  
    392392        }
    393393
    394         void ConversionCost::postvisit( const UnionInstType * inst ) {
    395                 if ( const UnionInstType * destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) {
     394        void ConversionCost::postvisit( UnionInstType * inst ) {
     395                if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
    396396                        if ( inst->name == destAsInst->name ) {
    397397                                cost = Cost::zero;
    … …  
    400400        }
    401401
    402         void ConversionCost::postvisit( const EnumInstType * ) {
     402        void ConversionCost::postvisit( EnumInstType * ) {
    403403                static Type::Qualifiers q;
    404404                static BasicType integer( q, BasicType::SignedInt );
    … …  
    409409        }
    410410
    411         void ConversionCost::postvisit( const TraitInstType * ) {}
    412 
    413         void ConversionCost::postvisit( const TypeInstType * inst ) {
    414                 if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
     411        void ConversionCost::postvisit( TraitInstType * ) {}
     412
     413        void ConversionCost::postvisit( TypeInstType *inst ) {
     414                if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) {
    415415                        cost = costFunc( eqvClass->type, dest, indexer, env );
    416                 } else if ( const TypeInstType * destAsInst = dynamic_cast< const TypeInstType * >( dest ) ) {
     416                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    417417                        if ( inst->name == destAsInst->name ) {
    418418                                cost = Cost::zero;
    419419                        }
    420                 } else if ( const NamedTypeDecl * namedType = indexer.lookupType( inst->name ) ) {
    421                         const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
     420                } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) {
     421                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    422422                        // all typedefs should be gone by this point
    423423                        assert( type );
    … …  
    428428        }
    429429
    430         void ConversionCost::postvisit( const TupleType * tupleType ) {
     430        void ConversionCost::postvisit( TupleType * tupleType ) {
    431431                Cost c = Cost::zero;
    432                 if ( const TupleType * destAsTuple = dynamic_cast< const TupleType * >( dest ) ) {
     432                if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
    433433                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
    434434                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
    435435                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
    436                                 Cost newCost = costFunc( * srcIt++, * destIt++, indexer, env );
     436                                Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env );
    437437                                if ( newCost == Cost::infinity ) {
    438438                                        return;
    … …  
    448448        }
    449449
    450         void ConversionCost::postvisit( const VarArgsType * ) {
    451                 if ( dynamic_cast< const VarArgsType * >( dest ) ) {
    452                         cost = Cost::zero;
    453                 }
    454         }
    455 
    456         void ConversionCost::postvisit( const ZeroType * ) {
    457                 if ( dynamic_cast< const ZeroType * >( dest ) ) {
    458                         cost = Cost::zero;
    459                 } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
    460                         // copied from visit(BasicType *) for signed int, but +1 for safe conversions
    461                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
     450        void ConversionCost::postvisit( VarArgsType * ) {
     451                if ( dynamic_cast< VarArgsType* >( dest ) ) {
     452                        cost = Cost::zero;
     453                }
     454        }
     455
     456        void ConversionCost::postvisit( ZeroType * ) {
     457                if ( dynamic_cast< ZeroType * >( dest ) ) {
     458                        cost = Cost::zero;
     459                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
     460                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
     461                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
    462462                        if ( tableResult == -1 ) {
    463463                                cost = Cost::unsafe;
    … …  
    465465                                cost = Cost::zero;
    466466                                cost.incSafe( tableResult + 1 );
    467                                 cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
    468                         } // if
    469                 } else if ( dynamic_cast< const PointerType * >( dest ) ) {
     467                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
     468                        } // if
     469                } else if ( dynamic_cast< PointerType* >( dest ) ) {
    470470                        cost = Cost::zero;
    471471                        cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation
    … …  
    473473        }
    474474
    475         void ConversionCost::postvisit( const OneType * ) {
    476                 if ( dynamic_cast< const OneType * >( dest ) ) {
    477                         cost = Cost::zero;
    478                 } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
    479                         // copied from visit(BasicType *) for signed int, but +1 for safe conversions
    480                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
     475        void ConversionCost::postvisit( OneType * ) {
     476                if ( dynamic_cast< OneType * >( dest ) ) {
     477                        cost = Cost::zero;
     478                } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
     479                        // copied from visit(BasicType*) for signed int, but +1 for safe conversions
     480                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
    481481                        if ( tableResult == -1 ) {
    482482                                cost = Cost::unsafe;
    … …  
    484484                                cost = Cost::zero;
    485485                                cost.incSafe( tableResult + 1 );
    486                                 cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
     486                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ] );
    487487                        } // if
    488488                } // if
    … …  
    729729                auto dstEnd = dstAsTuple->types.end();
    730730                while ( srcIt != srcEnd && dstIt != dstEnd ) {
    731                         Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
     731                        Cost newCost = costCalc( *srcIt++, *dstIt++, symtab, env );
    732732                        if ( newCost == Cost::infinity ) {
    733733                                return;

  • src/ResolvExpr/ConversionCost.h

    rfce4e31 r302d84c2  
    3333        class TypeEnvironment;
    3434
    35         typedef std::function<Cost(const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
     35        typedef std::function<Cost(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
    3636        struct ConversionCost : public WithShortCircuiting {
    3737          public:
    38                 ConversionCost( const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
     38                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
    3939
    4040                Cost get_cost() const { return cost; }
    4141
    42                 void previsit( const BaseSyntaxNode * ) { visit_children = false; }
     42                void previsit( BaseSyntaxNode * ) { visit_children = false; }
    4343
    44                 void postvisit( const VoidType * voidType );
    45                 void postvisit( const BasicType * basicType );
    46                 void postvisit( const PointerType * pointerType );
    47                 void postvisit( const ArrayType * arrayType );
    48                 void postvisit( const ReferenceType * refType );
    49                 void postvisit( const FunctionType * functionType );
    50                 void postvisit( const StructInstType * aggregateUseType );
    51                 void postvisit( const UnionInstType * aggregateUseType );
    52                 void postvisit( const EnumInstType * aggregateUseType );
    53                 void postvisit( const TraitInstType * aggregateUseType );
    54                 void postvisit( const TypeInstType * aggregateUseType );
    55                 void postvisit( const TupleType * tupleType );
    56                 void postvisit( const VarArgsType * varArgsType );
    57                 void postvisit( const ZeroType * zeroType );
    58                 void postvisit( const OneType * oneType );
     44                void postvisit( VoidType * voidType );
     45                void postvisit( BasicType * basicType );
     46                void postvisit( PointerType * pointerType );
     47                void postvisit( ArrayType * arrayType );
     48                void postvisit( ReferenceType * refType );
     49                void postvisit( FunctionType * functionType );
     50                void postvisit( StructInstType * aggregateUseType );
     51                void postvisit( UnionInstType * aggregateUseType );
     52                void postvisit( EnumInstType * aggregateUseType );
     53                void postvisit( TraitInstType * aggregateUseType );
     54                void postvisit( TypeInstType * aggregateUseType );
     55                void postvisit( TupleType * tupleType );
     56                void postvisit( VarArgsType * varArgsType );
     57                void postvisit( ZeroType * zeroType );
     58                void postvisit( OneType * oneType );
    5959          protected:
    60                 const Type * dest;
     60                Type *dest;
    6161                const SymTab::Indexer &indexer;
    6262                Cost cost;
    … …  
    6565        };
    6666
    67         typedef std::function<int(const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
    68         Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
     67        typedef std::function<int(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
     68        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
    6969
    7070// Some function pointer types, differ in return type.

  • src/ResolvExpr/PtrsAssignable.cc

    rfce4e31 r302d84c2  
    2727namespace ResolvExpr {
    2828        struct PtrsAssignable : public WithShortCircuiting {
    29                 PtrsAssignable( const Type * dest, const TypeEnvironment &env );
     29                PtrsAssignable( Type *dest, const TypeEnvironment &env );
    3030
    3131                int get_result() const { return result; }
    3232
    33                 void previsit( const Type * ) { visit_children = false; }
    34 
    35                 void postvisit( const VoidType * voidType );
    36                 void postvisit( const BasicType * basicType );
    37                 void postvisit( const PointerType * pointerType );
    38                 void postvisit( const ArrayType * arrayType );
    39                 void postvisit( const FunctionType * functionType );
    40                 void postvisit( const StructInstType * inst );
    41                 void postvisit( const UnionInstType * inst );
    42                 void postvisit( const EnumInstType * inst );
    43                 void postvisit( const TraitInstType * inst );
    44                 void postvisit( const TypeInstType * inst );
    45                 void postvisit( const TupleType * tupleType );
    46                 void postvisit( const VarArgsType * varArgsType );
    47                 void postvisit( const ZeroType * zeroType );
    48                 void postvisit( const OneType * oneType );
     33                void previsit( Type * ) { visit_children = false; }
     34
     35                void postvisit( VoidType * voidType );
     36                void postvisit( BasicType * basicType );
     37                void postvisit( PointerType * pointerType );
     38                void postvisit( ArrayType * arrayType );
     39                void postvisit( FunctionType * functionType );
     40                void postvisit( StructInstType * inst );
     41                void postvisit( UnionInstType * inst );
     42                void postvisit( EnumInstType * inst );
     43                void postvisit( TraitInstType * inst );
     44                void postvisit( TypeInstType * inst );
     45                void postvisit( TupleType * tupleType );
     46                void postvisit( VarArgsType * varArgsType );
     47                void postvisit( ZeroType * zeroType );
     48                void postvisit( OneType * oneType );
    4949          private:
    50                 const Type * dest;
     50                Type *dest;
    5151                int result;
    5252                const TypeEnvironment &env;
    5353        };
    5454
    55         int ptrsAssignable( const Type *src, const Type * dest, const TypeEnvironment &env ) {
     55        int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env ) {
    5656                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
    57                 if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
    58                         if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     57                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
     58                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    5959                                return ptrsAssignable( src, eqvClass->type, env );
    6060                        } // if
    6161                } // if
    62                 if ( dynamic_cast< const VoidType* >( dest ) ) {
     62                if ( dynamic_cast< VoidType* >( dest ) ) {
    6363                        // void * = T * for any T is unsafe
    6464                        // xxx - this should be safe, but that currently breaks the build
    … …  
    7171        }
    7272
    73         PtrsAssignable::PtrsAssignable( const Type * dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
    74 
    75         void PtrsAssignable::postvisit( const VoidType * ) {
     73        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
     74
     75        void PtrsAssignable::postvisit( VoidType * ) {
    7676                // T * = void * is disallowed - this is a change from C, where any
    7777                // void * can be assigned or passed to a non-void pointer without a cast.
    7878        }
    7979
    80         void PtrsAssignable::postvisit( const BasicType * ) {}
    81         void PtrsAssignable::postvisit( const PointerType * ) {}
    82         void PtrsAssignable::postvisit( const ArrayType * ) {}
    83         void PtrsAssignable::postvisit( const FunctionType * ) {}
    84 
    85         void PtrsAssignable::postvisit( const StructInstType * ) {}
    86         void PtrsAssignable::postvisit( const UnionInstType * ) {}
    87 
    88         void PtrsAssignable::postvisit( const EnumInstType * ) {
    89                 if ( dynamic_cast< const BasicType* >( dest ) ) {
     80        void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {}
     81        void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {}
     82        void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {}
     83        void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {}
     84
     85        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
     86        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
     87
     88        void PtrsAssignable::postvisit( EnumInstType * ) {
     89                if ( dynamic_cast< BasicType* >( dest ) ) {
    9090                        // int * = E *, etc. is safe. This isn't technically correct, as each
    9191                        // enum has one basic type that it is compatible with, an that type can
    … …  
    9797        }
    9898
    99         void PtrsAssignable::postvisit(  const TraitInstType * ) {}
    100         void PtrsAssignable::postvisit( const TypeInstType * inst ) {
    101                 if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
     99        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
     100        void PtrsAssignable::postvisit( TypeInstType *inst ) {
     101                if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) {
    102102                        if ( eqvClass->type ) {
    103103                                // T * = S * for any S depends on the type bound to T
    … …  
    107107        }
    108108
    109         void PtrsAssignable::postvisit( const TupleType * ) {}
    110         void PtrsAssignable::postvisit( const VarArgsType * ) {}
    111         void PtrsAssignable::postvisit( const ZeroType * ) {}
    112         void PtrsAssignable::postvisit( const OneType * ) {}
     109        void PtrsAssignable::postvisit(  __attribute__((unused)) TupleType *tupleType ) {}
     110        void PtrsAssignable::postvisit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
     111        void PtrsAssignable::postvisit(  __attribute__((unused)) ZeroType *zeroType ) {}
     112        void PtrsAssignable::postvisit(  __attribute__((unused)) OneType *oneType ) {}
    113113
    114114// TODO: Get rid of the `_new` suffix when the old version is removed.

  • src/ResolvExpr/PtrsCastable.cc

    rfce4e31 r302d84c2  
    2929        struct PtrsCastable_old : public WithShortCircuiting  {
    3030          public:
    31                 PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
     31                PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
    3232
    3333                int get_result() const { return result; }
    3434
    35                 void previsit( const Type * ) { visit_children = false; }
    36 
    37                 void postvisit( const VoidType * voidType );
    38                 void postvisit( const BasicType * basicType );
    39                 void postvisit( const PointerType * pointerType );
    40                 void postvisit( const ArrayType * arrayType );
    41                 void postvisit( const FunctionType * functionType );
    42                 void postvisit( const StructInstType * inst );
    43                 void postvisit( const UnionInstType * inst );
    44                 void postvisit( const EnumInstType * inst );
    45                 void postvisit( const TraitInstType * inst );
    46                 void postvisit( const TypeInstType * inst );
    47                 void postvisit( const TupleType * tupleType );
    48                 void postvisit( const VarArgsType * varArgsType );
    49                 void postvisit( const ZeroType * zeroType );
    50                 void postvisit( const OneType * oneType );
     35                void previsit( Type * ) { visit_children = false; }
     36
     37                void postvisit( VoidType * voidType );
     38                void postvisit( BasicType * basicType );
     39                void postvisit( PointerType * pointerType );
     40                void postvisit( ArrayType * arrayType );
     41                void postvisit( FunctionType * functionType );
     42                void postvisit( StructInstType * inst );
     43                void postvisit( UnionInstType * inst );
     44                void postvisit( EnumInstType * inst );
     45                void postvisit( TraitInstType * inst );
     46                void postvisit( TypeInstType * inst );
     47                void postvisit( TupleType * tupleType );
     48                void postvisit( VarArgsType * varArgsType );
     49                void postvisit( ZeroType * zeroType );
     50                void postvisit( OneType * oneType );
    5151          private:
    52                 const Type * dest;
     52                Type *dest;
    5353                int result;
    5454                const TypeEnvironment &env;
    … …  
    5757
    5858        namespace {
    59                 int objectCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    60                         if ( dynamic_cast< const FunctionType* >( src ) ) {
     59                int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
     60                        if ( dynamic_cast< FunctionType* >( src ) ) {
    6161                                return -1;
    62                         } else if ( const TypeInstType * typeInst = dynamic_cast< const TypeInstType* >( src ) ) {
    63                                 if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->name ) ) {
    64                                         if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl* >( ntDecl ) ) {
    65                                                 if ( tyDecl->kind == TypeDecl::Ftype ) {
     62                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
     63                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
     64                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
     65                                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    6666                                                        return -1;
    6767                                                } // if
    6868                                        } //if
    69                                 } else if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
     69                                } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) {
    7070                                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    7171                                                return -1;
    … …  
    7575                        return 1;
    7676                }
    77                 int functionCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
     77                int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    7878                        return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
    7979                }
    8080        }
    8181
    82         int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    83                 if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
    84                         if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     82        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
     83                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
     84                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    8585                                // xxx - should this be ptrsCastable?
    8686                                return ptrsAssignable( src, eqvClass->type, env );
    8787                        } // if
    8888                } // if
    89                 if ( dynamic_cast< const VoidType* >( dest ) ) {
     89                if ( dynamic_cast< VoidType* >( dest ) ) {
    9090                        return objectCast( src, env, indexer );
    9191                } else {
    … …  
    9696        }
    9797
    98         PtrsCastable_old::PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
     98        PtrsCastable_old::PtrsCastable_old( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
    9999                : dest( dest ), result( 0 ), env( env ), indexer( indexer )     {
    100100        }
    101101
    102         void PtrsCastable_old::postvisit( const VoidType * ) {
    103                 result = objectCast( dest, env, indexer );
    104         }
    105 
    106         void PtrsCastable_old::postvisit( const BasicType * ) {
    107                 result = objectCast( dest, env, indexer );
    108         }
    109 
    110         void PtrsCastable_old::postvisit( const PointerType * ) {
    111                 result = objectCast( dest, env, indexer );
    112         }
    113 
    114         void PtrsCastable_old::postvisit( const ArrayType * ) {
    115                 result = objectCast( dest, env, indexer );
    116         }
    117 
    118         void PtrsCastable_old::postvisit( const FunctionType * ) {
     102        void PtrsCastable_old::postvisit( VoidType * ) {
     103                result = objectCast( dest, env, indexer );
     104        }
     105
     106        void PtrsCastable_old::postvisit( BasicType * ) {
     107                result = objectCast( dest, env, indexer );
     108        }
     109
     110        void PtrsCastable_old::postvisit( PointerType * ) {
     111                result = objectCast( dest, env, indexer );
     112        }
     113
     114        void PtrsCastable_old::postvisit( ArrayType * ) {
     115                result = objectCast( dest, env, indexer );
     116        }
     117
     118        void PtrsCastable_old::postvisit( FunctionType * ) {
    119119                // result = -1;
    120120                result = functionCast( dest, env, indexer );
    121121        }
    122122
    123         void PtrsCastable_old::postvisit( const StructInstType * ) {
    124                 result = objectCast( dest, env, indexer );
    125         }
    126 
    127         void PtrsCastable_old::postvisit( const UnionInstType * ) {
    128                 result = objectCast( dest, env, indexer );
    129         }
    130 
    131         void PtrsCastable_old::postvisit( const EnumInstType * ) {
    132                 if ( dynamic_cast< const EnumInstType * >( dest ) ) {
     123        void PtrsCastable_old::postvisit( StructInstType * ) {
     124                result = objectCast( dest, env, indexer );
     125        }
     126
     127        void PtrsCastable_old::postvisit( UnionInstType * ) {
     128                result = objectCast( dest, env, indexer );
     129        }
     130
     131        void PtrsCastable_old::postvisit( EnumInstType * ) {
     132                if ( dynamic_cast< EnumInstType* >( dest ) ) {
    133133                        result = 1;
    134                 } else if ( const BasicType * bt = dynamic_cast< const BasicType * >( dest ) ) {
    135                         if ( bt->kind == BasicType::SignedInt ) {
     134                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
     135                        if ( bt->get_kind() == BasicType::SignedInt ) {
    136136                                result = 0;
    137137                        } else {
    … …  
    143143        }
    144144
    145         void PtrsCastable_old::postvisit( const TraitInstType * ) {}
    146 
    147         void PtrsCastable_old::postvisit( const TypeInstType *inst ) {
     145        void PtrsCastable_old::postvisit( TraitInstType * ) {}
     146
     147        void PtrsCastable_old::postvisit(TypeInstType *inst ) {
    148148                //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
    149149                result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
    150150        }
    151151
    152         void PtrsCastable_old::postvisit( const TupleType * ) {
    153                 result = objectCast( dest, env, indexer );
    154         }
    155 
    156         void PtrsCastable_old::postvisit( const VarArgsType * ) {
    157                 result = objectCast( dest, env, indexer );
    158         }
    159 
    160         void PtrsCastable_old::postvisit( const ZeroType * ) {
    161                 result = objectCast( dest, env, indexer );
    162         }
    163 
    164         void PtrsCastable_old::postvisit( const OneType * ) {
     152        void PtrsCastable_old::postvisit( TupleType * ) {
     153                result = objectCast( dest, env, indexer );
     154        }
     155
     156        void PtrsCastable_old::postvisit( VarArgsType * ) {
     157                result = objectCast( dest, env, indexer );
     158        }
     159
     160        void PtrsCastable_old::postvisit( ZeroType * ) {
     161                result = objectCast( dest, env, indexer );
     162        }
     163
     164        void PtrsCastable_old::postvisit( OneType * ) {
    165165                result = objectCast( dest, env, indexer );
    166166        }
    … …  
    168168namespace {
    169169        // can this type be cast to an object (1 for yes, -1 for no)
    170         int objectCast(
    171                 const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
     170        int objectCast( 
     171                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
    172172        ) {
    173173                if ( dynamic_cast< const ast::FunctionType * >( src ) ) {
    … …  
    191191
    192192        // can this type be cast to a function (inverse of objectCast)
    193         int functionCast(
    194                 const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
     193        int functionCast( 
     194                const ast::Type * src, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab 
    195195        ) {
    196196                return -1 * objectCast( src, env, symtab );
    … …  
    204204                int result;
    205205
    206                 PtrsCastable_new(
     206                PtrsCastable_new( 
    207207                        const ast::Type * d, const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
    208208                : dst( d ), env( e ), symtab( syms ), result( 0 ) {}
    … …  
    278278} // anonymous namespace
    279279
    280 int ptrsCastable(
    281         const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
    282         const ast::TypeEnvironment & env
     280int ptrsCastable( 
     281        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
     282        const ast::TypeEnvironment & env 
    283283) {
    284284        if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {

  • src/ResolvExpr/Resolver.cc

    rfce4e31 r302d84c2  
    562562                // TODO: Replace *exception type with &exception type.
    563563                if ( throwStmt->get_expr() ) {
    564                         StructDecl * exception_decl = indexer.lookupMutableStruct( "__cfaabi_ehm__base_exception_t" );
     564                        StructDecl * exception_decl =
     565                                indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
    565566                        assert( exception_decl );
    566567                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
    … …  
    971972                /// Calls the CandidateFinder and finds the single best candidate
    972973                CandidateRef findUnfinishedKindExpression(
    973                         const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind,
     974                        const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, 
    974975                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
    975976                ) {
    … …  
    993994                        // produce invalid error if no candidates
    994995                        if ( candidates.empty() ) {
    995                                 SemanticError( untyped,
    996                                         toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""),
     996                                SemanticError( untyped, 
     997                                        toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""), 
    997998                                        "expression: ") );
    998999                        }
    … …  
    10301031                        if ( winners.size() != 1 ) {
    10311032                                std::ostringstream stream;
    1032                                 stream << "Cannot choose between " << winners.size() << " alternatives for "
     1033                                stream << "Cannot choose between " << winners.size() << " alternatives for " 
    10331034                                        << kind << (kind != "" ? " " : "") << "expression\n";
    10341035                                ast::print( stream, untyped );
    … …  
    10531054                struct StripCasts_new final {
    10541055                        const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
    1055                                 if (
    1056                                         castExpr->isGenerated
    1057                                         && typesCompatible( castExpr->arg->result, castExpr->result )
     1056                                if ( 
     1057                                        castExpr->isGenerated 
     1058                                        && typesCompatible( castExpr->arg->result, castExpr->result ) 
    10581059                                ) {
    10591060                                        // generated cast is the same type as its argument, remove it after keeping env
    1060                                         return ast::mutate_field(
     1061                                        return ast::mutate_field( 
    10611062                                                castExpr->arg.get(), &ast::Expr::env, castExpr->env );
    10621063                                }
    … …  
    10871088
    10881089                /// Establish post-resolver invariants for expressions
    1089                 void finishExpr(
    1090                         ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
     1090                void finishExpr( 
     1091                        ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env, 
    10911092                        const ast::TypeSubstitution * oldenv = nullptr
    10921093                ) {
    10931094                        // set up new type substitution for expression
    1094                         ast::ptr< ast::TypeSubstitution > newenv =
     1095                        ast::ptr< ast::TypeSubstitution > newenv = 
    10951096                                 oldenv ? oldenv : new ast::TypeSubstitution{};
    10961097                        env.writeToSubstitution( *newenv.get_and_mutate() );
    … …  
    11011102        } // anonymous namespace
    11021103
    1103 
     1104               
    11041105        ast::ptr< ast::Expr > resolveInVoidContext(
    11051106                const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
    11061107        ) {
    11071108                assertf( expr, "expected a non-null expression" );
    1108 
     1109               
    11091110                // set up and resolve expression cast to void
    11101111                ast::CastExpr * untyped = new ast::CastExpr{ expr };
    1111                 CandidateRef choice = findUnfinishedKindExpression(
     1112                CandidateRef choice = findUnfinishedKindExpression( 
    11121113                        untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
    1113 
     1114               
    11141115                // a cast expression has either 0 or 1 interpretations (by language rules);
    11151116                // if 0, an exception has already been thrown, and this code will not run
    … …  
    11211122
    11221123        namespace {
    1123                 /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
     1124                /// Resolve `untyped` to the expression whose candidate is the best match for a `void` 
    11241125                /// context.
    1125                 ast::ptr< ast::Expr > findVoidExpression(
     1126                ast::ptr< ast::Expr > findVoidExpression( 
    11261127                        const ast::Expr * untyped, const ast::SymbolTable & symtab
    11271128                ) {
    … …  
    11331134                }
    11341135
    1135                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
     1136                /// resolve `untyped` to the expression whose candidate satisfies `pred` with the 
    11361137                /// lowest cost, returning the resolved version
    11371138                ast::ptr< ast::Expr > findKindExpression(
    1138                         const ast::Expr * untyped, const ast::SymbolTable & symtab,
    1139                         std::function<bool(const Candidate &)> pred = anyCandidate,
     1139                        const ast::Expr * untyped, const ast::SymbolTable & symtab, 
     1140                        std::function<bool(const Candidate &)> pred = anyCandidate, 
    11401141                        const std::string & kind = "", ResolvMode mode = {}
    11411142                ) {
    11421143                        if ( ! untyped ) return {};
    1143                         CandidateRef choice =
     1144                        CandidateRef choice = 
    11441145                                findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
    11451146                        finishExpr( choice->expr, choice->env, untyped->env );
    … …  
    11481149
    11491150                /// Resolve `untyped` to the single expression whose candidate is the best match
    1150                 ast::ptr< ast::Expr > findSingleExpression(
    1151                         const ast::Expr * untyped, const ast::SymbolTable & symtab
     1151                ast::ptr< ast::Expr > findSingleExpression( 
     1152                        const ast::Expr * untyped, const ast::SymbolTable & symtab 
    11521153                ) {
    11531154                        return findKindExpression( untyped, symtab );
    … …  
    11691170                bool hasIntegralType( const Candidate & i ) {
    11701171                        const ast::Type * type = i.expr->result;
    1171 
     1172                       
    11721173                        if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
    11731174                                return bt->isInteger();
    1174                         } else if (
    1175                                 dynamic_cast< const ast::EnumInstType * >( type )
     1175                        } else if ( 
     1176                                dynamic_cast< const ast::EnumInstType * >( type ) 
    11761177                                || dynamic_cast< const ast::ZeroType * >( type )
    11771178                                || dynamic_cast< const ast::OneType * >( type )
    … …  
    11821183
    11831184                /// Resolve `untyped` as an integral expression, returning the resolved version
    1184                 ast::ptr< ast::Expr > findIntegralExpression(
    1185                         const ast::Expr * untyped, const ast::SymbolTable & symtab
     1185                ast::ptr< ast::Expr > findIntegralExpression( 
     1186                        const ast::Expr * untyped, const ast::SymbolTable & symtab 
    11861187                ) {
    11871188                        return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
    … …  
    11911192                bool isCharType( const ast::Type * t ) {
    11921193                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
    1193                                 return bt->kind == ast::BasicType::Char
    1194                                         || bt->kind == ast::BasicType::SignedChar
     1194                                return bt->kind == ast::BasicType::Char 
     1195                                        || bt->kind == ast::BasicType::SignedChar 
    11951196                                        || bt->kind == ast::BasicType::UnsignedChar;
    11961197                        }
    … …  
    12521253        }
    12531254
    1254         ast::ptr< ast::Init > resolveCtorInit(
    1255                 const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab
     1255        ast::ptr< ast::Init > resolveCtorInit( 
     1256                const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab 
    12561257        ) {
    12571258                assert( ctorInit );
    … …  
    12601261        }
    12611262
    1262         ast::ptr< ast::Expr > resolveStmtExpr(
    1263                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
     1263        ast::ptr< ast::Expr > resolveStmtExpr( 
     1264                const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab 
    12641265        ) {
    12651266                assert( stmtExpr );
    … …  
    13021303
    13031304        void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
    1304                 // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()],
    1305                 // class-variable `initContext` is changed multiple times because the LHS is analyzed
    1306                 // twice. The second analysis changes `initContext` because a function type can contain
    1307                 // object declarations in the return and parameter types. Therefore each value of
    1308                 // `initContext` is retained so the type on the first analysis is preserved and used for
     1305                // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()], 
     1306                // class-variable `initContext` is changed multiple times because the LHS is analyzed 
     1307                // twice. The second analysis changes `initContext` because a function type can contain 
     1308                // object declarations in the return and parameter types. Therefore each value of 
     1309                // `initContext` is retained so the type on the first analysis is preserved and used for 
    13091310                // selecting the RHS.
    13101311                GuardValue( currentObject );
    13111312                currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
    13121313                if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
    1313                         // enumerator initializers should not use the enum type to initialize, since the
     1314                        // enumerator initializers should not use the enum type to initialize, since the 
    13141315                        // enum type is still incomplete at this point. Use `int` instead.
    1315                         currentObject = ast::CurrentObject{
     1316                        currentObject = ast::CurrentObject{ 
    13161317                                objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
    13171318                }
    … …  
    13241325        }
    13251326
    1326         const ast::StaticAssertDecl * Resolver_new::previsit(
    1327                 const ast::StaticAssertDecl * assertDecl
     1327        const ast::StaticAssertDecl * Resolver_new::previsit( 
     1328                const ast::StaticAssertDecl * assertDecl 
    13281329        ) {
    1329                 return ast::mutate_field(
    1330                         assertDecl, &ast::StaticAssertDecl::cond,
     1330                return ast::mutate_field( 
     1331                        assertDecl, &ast::StaticAssertDecl::cond, 
    13311332                        findIntegralExpression( assertDecl->cond, symtab ) );
    13321333        }
    … …  
    13371338                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
    13381339                        ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
    1339                         ast::mutate_field(
    1340                                 type, &PtrType::dimension,
     1340                        ast::mutate_field( 
     1341                                type, &PtrType::dimension, 
    13411342                                findSingleExpression( type->dimension, sizeType, symtab ) );
    13421343                }
    … …  
    13551356                visit_children = false;
    13561357                assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
    1357 
    1358                 return ast::mutate_field(
     1358               
     1359                return ast::mutate_field( 
    13591360                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
    13601361        }
    … …  
    13631364                visit_children = false;
    13641365
    1365                 asmExpr = ast::mutate_field(
     1366                asmExpr = ast::mutate_field( 
    13661367                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
    1367 
     1368               
    13681369                if ( asmExpr->inout ) {
    13691370                        asmExpr = ast::mutate_field(
    13701371                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
    13711372                }
    1372 
     1373               
    13731374                return asmExpr;
    13741375        }
    … …  
    13871388
    13881389        const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
    1389                 return ast::mutate_field(
     1390                return ast::mutate_field( 
    13901391                        whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
    13911392        }
    … …  
    14081409                GuardValue( currentObject );
    14091410                switchStmt = ast::mutate_field(
    1410                         switchStmt, &ast::SwitchStmt::cond,
     1411                        switchStmt, &ast::SwitchStmt::cond, 
    14111412                        findIntegralExpression( switchStmt->cond, symtab ) );
    14121413                currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
    … …  
    14191420                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
    14201421                                "expression." );
    1421 
    1422                         ast::ptr< ast::Expr > untyped =
     1422                       
     1423                        ast::ptr< ast::Expr > untyped = 
    14231424                                new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
    14241425                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, symtab );
    1425 
    1426                         // case condition cannot have a cast in C, so it must be removed here, regardless of
     1426                       
     1427                        // case condition cannot have a cast in C, so it must be removed here, regardless of 
    14271428                        // whether it would perform a conversion.
    14281429                        if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
    14291430                                swap_and_save_env( newExpr, castExpr->arg );
    14301431                        }
    1431 
     1432                       
    14321433                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
    14331434                }
    … …  
    14421443                        ast::ptr< ast::Type > target = new ast::PointerType{ new ast::VoidType{} };
    14431444                        branchStmt = ast::mutate_field(
    1444                                 branchStmt, &ast::BranchStmt::computedTarget,
     1445                                branchStmt, &ast::BranchStmt::computedTarget, 
    14451446                                findSingleExpression( branchStmt->computedTarget, target, symtab ) );
    14461447                }
    … …  
    14521453                if ( returnStmt->expr ) {
    14531454                        returnStmt = ast::mutate_field(
    1454                                 returnStmt, &ast::ReturnStmt::expr,
     1455                                returnStmt, &ast::ReturnStmt::expr, 
    14551456                                findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
    14561457                }
    … …  
    14611462                visit_children = false;
    14621463                if ( throwStmt->expr ) {
    1463                         const ast::StructDecl * exceptionDecl =
     1464                        const ast::StructDecl * exceptionDecl = 
    14641465                                symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
    14651466                        assert( exceptionDecl );
    1466                         ast::ptr< ast::Type > exceptType =
     1467                        ast::ptr< ast::Type > exceptType = 
    14671468                                new ast::PointerType{ new ast::StructInstType{ exceptionDecl } };
    14681469                        throwStmt = ast::mutate_field(
    1469                                 throwStmt, &ast::ThrowStmt::expr,
     1470                                throwStmt, &ast::ThrowStmt::expr, 
    14701471                                findSingleExpression( throwStmt->expr, exceptType, symtab ) );
    14711472                }
    … …  
    14761477                if ( catchStmt->cond ) {
    14771478                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
    1478                         catchStmt = ast::mutate_field(
    1479                                 catchStmt, &ast::CatchStmt::cond,
     1479                        catchStmt = ast::mutate_field( 
     1480                                catchStmt, &ast::CatchStmt::cond, 
    14801481                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
    14811482                }
    … …  
    15051506
    15061507                        if ( clause.target.args.empty() ) {
    1507                                 SemanticError( stmt->location,
     1508                                SemanticError( stmt->location, 
    15081509                                        "Waitfor clause must have at least one mutex parameter");
    15091510                        }
    15101511
    15111512                        // Find all alternatives for all arguments in canonical form
    1512                         std::vector< CandidateFinder > argFinders =
     1513                        std::vector< CandidateFinder > argFinders = 
    15131514                                funcFinder.findSubExprs( clause.target.args );
    1514 
     1515                       
    15151516                        // List all combinations of arguments
    15161517                        std::vector< CandidateList > possibilities;
    … …  
    15181519
    15191520                        // For every possible function:
    1520                         // * try matching the arguments to the parameters, not the other way around because
     1521                        // * try matching the arguments to the parameters, not the other way around because 
    15211522                        //   more arguments than parameters
    15221523                        CandidateList funcCandidates;
    … …  
    15251526                        for ( CandidateRef & func : funcFinder.candidates ) {
    15261527                                try {
    1527                                         auto pointerType = dynamic_cast< const ast::PointerType * >(
     1528                                        auto pointerType = dynamic_cast< const ast::PointerType * >( 
    15281529                                                func->expr->result->stripReferences() );
    15291530                                        if ( ! pointerType ) {
    1530                                                 SemanticError( stmt->location, func->expr->result.get(),
     1531                                                SemanticError( stmt->location, func->expr->result.get(), 
    15311532                                                        "candidate not viable: not a pointer type\n" );
    15321533                                        }
    … …  
    15341535                                        auto funcType = pointerType->base.as< ast::FunctionType >();
    15351536                                        if ( ! funcType ) {
    1536                                                 SemanticError( stmt->location, func->expr->result.get(),
     1537                                                SemanticError( stmt->location, func->expr->result.get(), 
    15371538                                                        "candidate not viable: not a function type\n" );
    15381539                                        }
    … …  
    15431544
    15441545                                                if( ! nextMutex( param, paramEnd ) ) {
    1545                                                         SemanticError( stmt->location, funcType,
     1546                                                        SemanticError( stmt->location, funcType, 
    15461547                                                                "candidate function not viable: no mutex parameters\n");
    15471548                                                }
    … …  
    15591560                                                        ast::AssertionSet need, have;
    15601561                                                        ast::TypeEnvironment resultEnv{ func->env };
    1561                                                         // Add all type variables as open so that those not used in the
     1562                                                        // Add all type variables as open so that those not used in the 
    15621563                                                        // parameter list are still considered open
    15631564                                                        resultEnv.add( funcType->forall );
    … …  
    15791580                                                        unsigned n_mutex_param = 0;
    15801581
    1581                                                         // For every argument of its set, check if it matches one of the
     1582                                                        // For every argument of its set, check if it matches one of the 
    15821583                                                        // parameters. The order is important
    15831584                                                        for ( auto & arg : argsList ) {
    … …  
    15861587                                                                        // We ran out of parameters but still have arguments.
    15871588                                                                        // This function doesn't match
    1588                                                                         SemanticError( stmt->location, funcType,
     1589                                                                        SemanticError( stmt->location, funcType, 
    15891590                                                                                toString("candidate function not viable: too many mutex "
    15901591                                                                                "arguments, expected ", n_mutex_param, "\n" ) );
    … …  
    15931594                                                                ++n_mutex_param;
    15941595
    1595                                                                 // Check if the argument matches the parameter type in the current
     1596                                                                // Check if the argument matches the parameter type in the current 
    15961597                                                                // scope
    15971598                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
    1598                                                                 if (
    1599                                                                         ! unify(
    1600                                                                                 arg->expr->result, paramType, resultEnv, need, have, open,
    1601                                                                                 symtab )
     1599                                                                if ( 
     1600                                                                        ! unify( 
     1601                                                                                arg->expr->result, paramType, resultEnv, need, have, open, 
     1602                                                                                symtab ) 
    16021603                                                                ) {
    16031604                                                                        // Type doesn't match
    … …  
    16261627                                                                } while ( nextMutex( param, paramEnd ) );
    16271628
    1628                                                                 // We ran out of arguments but still have parameters left; this
     1629                                                                // We ran out of arguments but still have parameters left; this 
    16291630                                                                // function doesn't match
    1630                                                                 SemanticError( stmt->location, funcType,
     1631                                                                SemanticError( stmt->location, funcType, 
    16311632                                                                        toString( "candidate function not viable: too few mutex "
    16321633                                                                        "arguments, expected ", n_mutex_param, "\n" ) );
    … …  
    16561657                        // Make sure correct number of arguments
    16571658                        if( funcCandidates.empty() ) {
    1658                                 SemanticErrorException top( stmt->location,
     1659                                SemanticErrorException top( stmt->location, 
    16591660                                        "No alternatives for function in call to waitfor" );
    16601661                                top.append( errors );
    … …  
    16631664
    16641665                        if( argsCandidates.empty() ) {
    1665                                 SemanticErrorException top( stmt->location,
    1666                                         "No alternatives for arguments in call to waitfor" );
     1666                                SemanticErrorException top( stmt->location, 
     1667                                        "No alternatives for arguments in call to waitfor" ); 
    16671668                                top.append( errors );
    16681669                                throw top;
    … …  
    16701671
    16711672                        if( funcCandidates.size() > 1 ) {
    1672                                 SemanticErrorException top( stmt->location,
     1673                                SemanticErrorException top( stmt->location, 
    16731674                                        "Ambiguous function in call to waitfor" );
    16741675                                top.append( errors );
    … …  
    16851686                        // build new clause
    16861687                        ast::WaitForStmt::Clause clause2;
    1687 
     1688                       
    16881689                        clause2.target.func = funcCandidates.front()->expr;
    1689 
     1690                       
    16901691                        clause2.target.args.reserve( clause.target.args.size() );
    16911692                        for ( auto arg : argsCandidates.front() ) {
    … …  
    17071708                        ast::WaitForStmt::Timeout timeout2;
    17081709
    1709                         ast::ptr< ast::Type > target =
     1710                        ast::ptr< ast::Type > target = 
    17101711                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
    17111712                        timeout2.time = findSingleExpression( stmt->timeout.time, target, symtab );
    … …  
    17391740        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
    17401741                visit_children = false;
    1741                 // resolve initialization using the possibilities as determined by the `currentObject`
     1742                // resolve initialization using the possibilities as determined by the `currentObject` 
    17421743                // cursor.
    1743                 ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{
     1744                ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{ 
    17441745                        singleInit->location, singleInit->value, currentObject.getOptions() };
    17451746                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, symtab );
    … …  
    17501751
    17511752                // discard InitExpr wrapper and retain relevant pieces.
    1752                 // `initExpr` may have inferred params in the case where the expression specialized a
    1753                 // function pointer, and newExpr may already have inferParams of its own, so a simple
     1753                // `initExpr` may have inferred params in the case where the expression specialized a 
     1754                // function pointer, and newExpr may already have inferParams of its own, so a simple 
    17541755                // swap is not sufficient
    17551756                ast::Expr::InferUnion inferred = initExpr->inferred;
    … …  
    17571758                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
    17581759
    1759                 // get the actual object's type (may not exactly match what comes back from the resolver
     1760                // get the actual object's type (may not exactly match what comes back from the resolver 
    17601761                // due to conversions)
    17611762                const ast::Type * initContext = currentObject.getCurrentType();
    … …  
    17691770                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
    17701771                                        if ( isCharType( pt->base ) ) {
    1771                                                 // strip cast if we're initializing a char[] with a char*
     1772                                                // strip cast if we're initializing a char[] with a char* 
    17721773                                                // e.g. char x[] = "hello"
    17731774                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
    … …  
    17921793                assert( listInit->designations.size() == listInit->initializers.size() );
    17931794                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
    1794                         // iterate designations and initializers in pairs, moving the cursor to the current
     1795                        // iterate designations and initializers in pairs, moving the cursor to the current 
    17951796                        // designated object and resolving the initializer against that object
    17961797                        listInit = ast::mutate_field_index(
    1797                                 listInit, &ast::ListInit::designations, i,
     1798                                listInit, &ast::ListInit::designations, i, 
    17981799                                currentObject.findNext( listInit->designations[i] ) );
    17991800                        listInit = ast::mutate_field_index(
    … …  
    18171818                ctorInit = ast::mutate_field( ctorInit, &ast::ConstructorInit::init, nullptr );
    18181819
    1819                 // intrinsic single-parameter constructors and destructors do nothing. Since this was
    1820                 // implicitly generated, there's no way for it to have side effects, so get rid of it to
     1820                // intrinsic single-parameter constructors and destructors do nothing. Since this was 
     1821                // implicitly generated, there's no way for it to have side effects, so get rid of it to 
    18211822                // clean up generated code
    18221823                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {

  • src/ResolvExpr/Unify.cc

    rfce4e31 r302d84c2  
    9797        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
    9898
    99         bool unifyExact(
    100                 const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
    101                 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
     99        bool unifyExact( 
     100                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
     101                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
    102102                WidenMode widen, const ast::SymbolTable & symtab );
    103103
    … …  
    121121        }
    122122
    123         bool typesCompatible(
    124                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
     123        bool typesCompatible( 
     124                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
    125125                        const ast::TypeEnvironment & env ) {
    126126                ast::TypeEnvironment newEnv;
    … …  
    135135                findOpenVars( newSecond, open, closed, need, have, FirstOpen );
    136136
    137                 return unifyExact(
     137                return unifyExact( 
    138138                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
    139139        }
    140140
    141         bool typesCompatibleIgnoreQualifiers( const Type * first, const Type * second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     141        bool typesCompatibleIgnoreQualifiers( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    142142                TypeEnvironment newEnv;
    143143                OpenVarSet openVars;
    … …  
    163163        }
    164164
    165         bool typesCompatibleIgnoreQualifiers(
    166                         const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab,
     165        bool typesCompatibleIgnoreQualifiers( 
     166                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
    167167                        const ast::TypeEnvironment & env ) {
    168168                ast::TypeEnvironment newEnv;
    169169                ast::OpenVarSet open;
    170170                ast::AssertionSet need, have;
    171 
     171               
    172172                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
    173173                env.apply( newFirst );
    … …  
    176176                reset_qualifiers( newSecond );
    177177
    178                 return unifyExact(
     178                return unifyExact( 
    179179                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
    180180        }
    … …  
    490490
    491491                        // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors
    492                         if (
    493                                         (flatFunc->parameters.size() == flatOther->parameters.size() &&
    494                                                 flatFunc->returnVals.size() == flatOther->returnVals.size())
    495                                         || flatFunc->isTtype()
    496                                         || flatOther->isTtype()
     492                        if ( 
     493                                        (flatFunc->parameters.size() == flatOther->parameters.size() && 
     494                                                flatFunc->returnVals.size() == flatOther->returnVals.size()) 
     495                                        || flatFunc->isTtype() 
     496                                        || flatOther->isTtype() 
    497497                        ) {
    498498                                if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
    … …  
    711711                bool result;
    712712
    713                 Unify_new(
    714                         const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need,
    715                         ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen,
     713                Unify_new( 
     714                        const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need, 
     715                        ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen, 
    716716                        const ast::SymbolTable & symtab )
    717                 : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen),
     717                : type2(type2), tenv(env), need(need), have(have), open(open), widen(widen), 
    718718                  symtab(symtab), result(false) {}
    719719
    720720                void previsit( const ast::Node * ) { visit_children = false; }
    721 
     721               
    722722                void postvisit( const ast::VoidType * ) {
    723723                        result = dynamic_cast< const ast::VoidType * >( type2 );
    … …  
    732732                void postvisit( const ast::PointerType * pointer ) {
    733733                        if ( auto pointer2 = dynamic_cast< const ast::PointerType * >( type2 ) ) {
    734                                 result = unifyExact(
    735                                         pointer->base, pointer2->base, tenv, need, have, open,
     734                                result = unifyExact( 
     735                                        pointer->base, pointer2->base, tenv, need, have, open, 
    736736                                        noWiden(), symtab );
    737737                        }
    … …  
    742742                        if ( ! array2 ) return;
    743743
    744                         // to unify, array types must both be VLA or both not VLA and both must have a
     744                        // to unify, array types must both be VLA or both not VLA and both must have a 
    745745                        // dimension expression or not have a dimension
    746746                        if ( array->isVarLen != array2->isVarLen ) return;
    747                         if ( ! array->isVarLen && ! array2->isVarLen
     747                        if ( ! array->isVarLen && ! array2->isVarLen 
    748748                                        && array->dimension && array2->dimension ) {
    749749                                auto ce1 = array->dimension.as< ast::ConstantExpr >();
    … …  
    751751
    752752                                // see C11 Reference Manual 6.7.6.2.6
    753                                 // two array types with size specifiers that are integer constant expressions are
     753                                // two array types with size specifiers that are integer constant expressions are 
    754754                                // compatible if both size specifiers have the same constant value
    755755                                if ( ce1 && ce2 && ce1->intValue() != ce2->intValue() ) return;
    756756                        }
    757757
    758                         result = unifyExact(
    759                                 array->base, array2->base, tenv, need, have, open, noWiden(),
     758                        result = unifyExact( 
     759                                array->base, array2->base, tenv, need, have, open, noWiden(), 
    760760                                symtab );
    761761                }
    … …  
    763763                void postvisit( const ast::ReferenceType * ref ) {
    764764                        if ( auto ref2 = dynamic_cast< const ast::ReferenceType * >( type2 ) ) {
    765                                 result = unifyExact(
    766                                         ref->base, ref2->base, tenv, need, have, open, noWiden(),
     765                                result = unifyExact( 
     766                                        ref->base, ref2->base, tenv, need, have, open, noWiden(), 
    767767                                        symtab );
    768768                        }
    … …  
    771771        private:
    772772                /// Replaces ttype variables with their bound types.
    773                 /// If this isn't done when satifying ttype assertions, then argument lists can have
     773                /// If this isn't done when satifying ttype assertions, then argument lists can have 
    774774                /// different size and structure when they should be compatible.
    775775                struct TtypeExpander_new : public ast::WithShortCircuiting {
    … …  
    800800                                auto types = flatten( d->get_type() );
    801801                                for ( ast::ptr< ast::Type > & t : types ) {
    802                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
    803                                         // a role in the unification of function types, since they do not determine
     802                                        // outermost const, volatile, _Atomic qualifiers in parameters should not play 
     803                                        // a role in the unification of function types, since they do not determine 
    804804                                        // whether a function is callable.
    805                                         // NOTE: **must** consider at least mutex qualifier, since functions can be
    806                                         // overloaded on outermost mutex and a mutex function has different
     805                                        // NOTE: **must** consider at least mutex qualifier, since functions can be 
     806                                        // overloaded on outermost mutex and a mutex function has different 
    807807                                        // requirements than a non-mutex function
    808808                                        remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
    … …  
    818818                        std::vector< ast::ptr< ast::Type > > types;
    819819                        while ( crnt != end ) {
    820                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
     820                                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure 
    821821                                // that this results in a flat tuple
    822822                                flatten( (*crnt)->get_type(), types );
    … …  
    829829
    830830                template< typename Iter >
    831                 static bool unifyDeclList(
    832                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
    833                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
     831                static bool unifyDeclList( 
     832                        Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env, 
     833                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
    834834                        const ast::SymbolTable & symtab
    835835                ) {
    … …  
    843843                                if ( isTuple1 && ! isTuple2 ) {
    844844                                        // combine remainder of list2, then unify
    845                                         return unifyExact(
    846                                                 t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
     845                                        return unifyExact( 
     846                                                t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
    847847                                                noWiden(), symtab );
    848848                                } else if ( ! isTuple1 && isTuple2 ) {
    849849                                        // combine remainder of list1, then unify
    850                                         return unifyExact(
    851                                                 tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
     850                                        return unifyExact( 
     851                                                tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
    852852                                                noWiden(), symtab );
    853853                                }
    854854
    855                                 if ( ! unifyExact(
    856                                         t1, t2, env, need, have, open, noWiden(), symtab )
     855                                if ( ! unifyExact( 
     856                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
    857857                                ) return false;
    858858
    … …  
    860860                        }
    861861
    862                         // May get to the end of one argument list before the other. This is only okay if the
     862                        // May get to the end of one argument list before the other. This is only okay if the 
    863863                        // other is a ttype
    864864                        if ( crnt1 != end1 ) {
    … …  
    866866                                const ast::Type * t1 = (*crnt1)->get_type();
    867867                                if ( ! Tuples::isTtype( t1 ) ) return false;
    868                                 return unifyExact(
    869                                         t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
     868                                return unifyExact( 
     869                                        t1, tupleFromDecls( crnt2, end2 ), env, need, have, open, 
    870870                                        noWiden(), symtab );
    871871                        } else if ( crnt2 != end2 ) {
    … …  
    873873                                const ast::Type * t2 = (*crnt2)->get_type();
    874874                                if ( ! Tuples::isTtype( t2 ) ) return false;
    875                                 return unifyExact(
    876                                         tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
     875                                return unifyExact( 
     876                                        tupleFromDecls( crnt1, end1 ), t2, env, need, have, open, 
    877877                                        noWiden(), symtab );
    878878                        }
    … …  
    881881                }
    882882
    883                 static bool unifyDeclList(
    884                         const std::vector< ast::ptr< ast::DeclWithType > > & list1,
    885                         const std::vector< ast::ptr< ast::DeclWithType > > & list2,
    886                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
     883                static bool unifyDeclList( 
     884                        const std::vector< ast::ptr< ast::DeclWithType > > & list1, 
     885                        const std::vector< ast::ptr< ast::DeclWithType > > & list2, 
     886                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
    887887                        const ast::OpenVarSet & open, const ast::SymbolTable & symtab
    888888                ) {
    889                         return unifyDeclList(
    890                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
     889                        return unifyDeclList( 
     890                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open, 
    891891                                symtab );
    892892                }
    … …  
    900900
    901901                /// mark all assertions in `type` used in both `assn1` and `assn2`
    902                 static void markAssertions(
    903                         ast::AssertionSet & assn1, ast::AssertionSet & assn2,
    904                         const ast::ParameterizedType * type
     902                static void markAssertions( 
     903                        ast::AssertionSet & assn1, ast::AssertionSet & assn2, 
     904                        const ast::ParameterizedType * type 
    905905                ) {
    906906                        for ( const auto & tyvar : type->forall ) {
    … …  
    918918
    919919                        if ( func->isVarArgs != func2->isVarArgs ) return;
    920 
    921                         // Flatten the parameter lists for both functions so that tuple structure does not
     920                       
     921                        // Flatten the parameter lists for both functions so that tuple structure does not 
    922922                        // affect unification. Does not actually mutate function parameters.
    923923                        auto params = flattenList( func->params, tenv );
    924924                        auto params2 = flattenList( func2->params, tenv );
    925925
    926                         // sizes don't have to match if ttypes are involved; need to be more precise w.r.t.
     926                        // sizes don't have to match if ttypes are involved; need to be more precise w.r.t. 
    927927                        // where the ttype is to prevent errors
    928                         if (
     928                        if ( 
    929929                                ( params.size() != params2.size() || func->returns.size() != func2->returns.size() )
    930930                                && ! func->isTtype()
    … …  
    933933
    934934                        if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
    935                         if ( ! unifyDeclList(
     935                        if ( ! unifyDeclList( 
    936936                                func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
    937 
     937                       
    938938                        markAssertions( have, need, func );
    939939                        markAssertions( have, need, func2 );
    … …  
    941941                        result = true;
    942942                }
    943 
     943       
    944944        private:
    945945                template< typename RefType >
    … …  
    953953                /// Creates a tuple type based on a list of TypeExpr
    954954                template< typename Iter >
    955                 static const ast::Type * tupleFromExprs(
     955                static const ast::Type * tupleFromExprs( 
    956956                        const ast::TypeExpr * param, Iter & crnt, Iter end, ast::CV::Qualifiers qs
    957957                ) {
    … …  
    973973                        const RefType * inst2 = handleRefType( inst, other );
    974974                        if ( ! inst2 ) return;
    975 
     975                       
    976976                        // check that parameters of types unify, if any
    977977                        const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
    … …  
    10021002                                }
    10031003
    1004                                 if ( ! unifyExact(
     1004                                if ( ! unifyExact( 
    10051005                                                pty, pty2, tenv, need, have, open, noWiden(), symtab ) ) {
    10061006                                        result = false;
    … …  
    10381038        private:
    10391039                /// Creates a tuple type based on a list of Type
    1040                 static ast::ptr< ast::Type > tupleFromTypes(
     1040                static ast::ptr< ast::Type > tupleFromTypes( 
    10411041                        const std::vector< ast::ptr< ast::Type > > & tys
    10421042                ) {
    10431043                        std::vector< ast::ptr< ast::Type > > out;
    10441044                        for ( const ast::Type * ty : tys ) {
    1045                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
     1045                                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure 
    10461046                                // that this results in a flat tuple
    10471047                                flatten( ty, out );
    … …  
    10511051                }
    10521052
    1053                 static bool unifyList(
    1054                         const std::vector< ast::ptr< ast::Type > > & list1,
    1055                         const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env,
    1056                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
     1053                static bool unifyList( 
     1054                        const std::vector< ast::ptr< ast::Type > > & list1, 
     1055                        const std::vector< ast::ptr< ast::Type > > & list2, ast::TypeEnvironment & env, 
     1056                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
    10571057                        const ast::SymbolTable & symtab
    10581058                ) {
    … …  
    10681068                                if ( isTuple1 && ! isTuple2 ) {
    10691069                                        // combine entirety of list2, then unify
    1070                                         return unifyExact(
    1071                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
     1070                                        return unifyExact( 
     1071                                                t1, tupleFromTypes( list2 ), env, need, have, open, 
    10721072                                                noWiden(), symtab );
    10731073                                } else if ( ! isTuple1 && isTuple2 ) {
    10741074                                        // combine entirety of list1, then unify
    10751075                                        return unifyExact(
    1076                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
     1076                                                tupleFromTypes( list1 ), t2, env, need, have, open, 
    10771077                                                noWiden(), symtab );
    10781078                                }
    10791079
    1080                                 if ( ! unifyExact(
    1081                                         t1, t2, env, need, have, open, noWiden(), symtab )
     1080                                if ( ! unifyExact( 
     1081                                        t1, t2, env, need, have, open, noWiden(), symtab ) 
    10821082                                ) return false;
    10831083
    … …  
    10891089                                const ast::Type * t1 = *crnt1;
    10901090                                if ( ! Tuples::isTtype( t1 ) ) return false;
    1091                                 // xxx - this doesn't generate an empty tuple, contrary to comment; both ported
     1091                                // xxx - this doesn't generate an empty tuple, contrary to comment; both ported 
    10921092                                // from Rob's code
    1093                                 return unifyExact(
    1094                                                 t1, tupleFromTypes( list2 ), env, need, have, open,
     1093                                return unifyExact( 
     1094                                                t1, tupleFromTypes( list2 ), env, need, have, open, 
    10951095                                                noWiden(), symtab );
    10961096                        } else if ( crnt2 != list2.end() ) {
    … …  
    10981098                                const ast::Type * t2 = *crnt2;
    10991099                                if ( ! Tuples::isTtype( t2 ) ) return false;
    1100                                 // xxx - this doesn't generate an empty tuple, contrary to comment; both ported
     1100                                // xxx - this doesn't generate an empty tuple, contrary to comment; both ported 
    11011101                                // from Rob's code
    11021102                                return unifyExact(
    1103                                                 tupleFromTypes( list1 ), t2, env, need, have, open,
     1103                                                tupleFromTypes( list1 ), t2, env, need, have, open, 
    11041104                                                noWiden(), symtab );
    11051105                        }
    … …  
    11331133                void postvisit( const ast::OneType * ) {
    11341134                        result = dynamic_cast< const ast::OneType * >( type2 );
    1135                 }
     1135                }       
    11361136
    11371137          private:
    … …  
    11401140        };
    11411141
    1142         bool unify(
    1143                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1144                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
     1142        bool unify( 
     1143                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
     1144                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
    11451145                        ast::OpenVarSet & open, const ast::SymbolTable & symtab
    11461146        ) {
    … …  
    11491149        }
    11501150
    1151         bool unify(
    1152                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1153                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    1154                         ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common
     1151        bool unify( 
     1152                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
     1153                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
     1154                        ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common 
    11551155        ) {
    11561156                ast::OpenVarSet closed;
    11571157                findOpenVars( type1, open, closed, need, have, FirstClosed );
    11581158                findOpenVars( type2, open, closed, need, have, FirstOpen );
    1159                 return unifyInexact(
     1159                return unifyInexact( 
    11601160                        type1, type2, env, need, have, open, WidenMode{ true, true }, symtab, common );
    11611161        }
    11621162
    1163         bool unifyExact(
    1164                         const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
    1165                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
     1163        bool unifyExact( 
     1164                        const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
     1165                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
    11661166                        WidenMode widen, const ast::SymbolTable & symtab
    11671167        ) {
    … …  
    11701170                auto var1 = dynamic_cast< const ast::TypeInstType * >( type1 );
    11711171                auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
    1172                 ast::OpenVarSet::const_iterator
    1173                         entry1 = var1 ? open.find( var1->name ) : open.end(),
     1172                ast::OpenVarSet::const_iterator 
     1173                        entry1 = var1 ? open.find( var1->name ) : open.end(), 
    11741174                        entry2 = var2 ? open.find( var2->name ) : open.end();
    11751175                bool isopen1 = entry1 != open.end();
    … …  
    11781178                if ( isopen1 && isopen2 ) {
    11791179                        if ( entry1->second.kind != entry2->second.kind ) return false;
    1180                         return env.bindVarToVar(
    1181                                 var1, var2, ast::TypeDecl::Data{ entry1->second, entry2->second }, need, have,
     1180                        return env.bindVarToVar( 
     1181                                var1, var2, ast::TypeDecl::Data{ entry1->second, entry2->second }, need, have, 
    11821182                                open, widen, symtab );
    11831183                } else if ( isopen1 ) {
    … …  
    11921192        }
    11931193
    1194         bool unifyInexact(
    1195                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
    1196                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    1197                         const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab,
    1198                         ast::ptr<ast::Type> & common
     1194        bool unifyInexact( 
     1195                        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
     1196                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
     1197                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
     1198                        ast::ptr<ast::Type> & common 
    11991199        ) {
    12001200                ast::CV::Qualifiers q1 = type1->qualifiers, q2 = type2->qualifiers;
    1201 
    1202                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
     1201               
     1202                // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and 
    12031203                // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
    12041204                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
    12051205                reset_qualifiers( t1 );
    12061206                reset_qualifiers( t2 );
    1207 
     1207               
    12081208                if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
    12091209                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones

  • src/ResolvExpr/typeops.h

    rfce4e31 r302d84c2  
    7373
    7474        /// Replaces array types with equivalent pointer, and function types with a pointer-to-function
    75         const ast::Type * adjustExprType(
     75        const ast::Type * adjustExprType( 
    7676                const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab );
    7777
    7878        // in CastCost.cc
    79         Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
    80         Cost castCost(
    81                 const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
     79        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
     80        Cost castCost( 
     81                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
    8282                const ast::TypeEnvironment & env );
    8383
    8484        // in ConversionCost.cc
    85         Cost conversionCost( const Type *src, const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
    86         Cost conversionCost(
    87                 const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
     85        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
     86        Cost conversionCost( 
     87                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
    8888                const ast::TypeEnvironment & env );
    8989
    9090        // in AlternativeFinder.cc
    91         Cost computeConversionCost( Type *actualType, Type *formalType,
     91        Cost computeConversionCost( Type *actualType, Type *formalType, 
    9292                const SymTab::Indexer &indexer, const TypeEnvironment &env );
    9393
    9494        // in PtrsAssignable.cc
    95         int ptrsAssignable( const Type * src, const Type * dest, const TypeEnvironment &env );
     95        int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env );
    9696        int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
    9797                const ast::TypeEnvironment & env );
    9898
    9999        // in PtrsCastable.cc
    100         int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
    101         int ptrsCastable(
    102                 const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
     100        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
     101        int ptrsCastable( 
     102                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
    103103                const ast::TypeEnvironment & env );
    104104
    105105        // in Unify.cc
    106106        bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
    107         bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
     107        bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
    108108
    109109        inline bool typesCompatible( Type *t1, Type *t2, const SymTab::Indexer &indexer ) {
    … …  
    112112        }
    113113
    114         inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer &indexer ) {
     114        inline bool typesCompatibleIgnoreQualifiers( Type *t1, Type *t2, const SymTab::Indexer &indexer ) {
    115115                TypeEnvironment env;
    116116                return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
    117117        }
    118118
    119         bool typesCompatible(
    120                 const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
     119        bool typesCompatible( 
     120                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {}, 
    121121                const ast::TypeEnvironment & env = {} );
    122 
     122       
    123123        bool typesCompatibleIgnoreQualifiers(
    124                 const ast::Type *, const ast::Type *, const ast::SymbolTable &,
     124                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
    125125                const ast::TypeEnvironment & env = {} );
    126126
    … …  
    133133        Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    134134        ast::ptr< ast::Type > commonType(
    135                 const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen,
     135                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen, 
    136136                const ast::SymbolTable & symtab, ast::TypeEnvironment & env, const ast::OpenVarSet & open );
    137137
    138138        // in PolyCost.cc
    139139        int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
    140         int polyCost(
     140        int polyCost( 
    141141                const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
    142142
    … …  
    149149        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
    150150
    151         template<typename Iter>
     151        template<typename Iter> 
    152152        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) {
    153153                while ( begin != end ) {
    … …  
    176176
    177177        /// flatten tuple type into existing list of types
    178         static inline void flatten(
    179                 const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
     178        static inline void flatten( 
     179                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out 
    180180        ) {
    181                 if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
     181                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {       
    182182                        for ( const ast::Type * t : tupleType->types ) {
    183183                                flatten( t, out );

  • src/SymTab/Indexer.cc

    rfce4e31 r302d84c2  
    7474        }
    7575
    76         Indexer::Indexer()
    77         : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
    78           prevScope(), scope( 0 ), repScope( 0 ) { ++* stats().count; }
     76        Indexer::Indexer() 
     77        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(), 
     78          prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; }
    7979
    8080        Indexer::~Indexer() {
    … …  
    8484        void Indexer::lazyInitScope() {
    8585                if ( repScope < scope ) {
    86                         ++* stats().lazy_scopes;
     86                        ++*stats().lazy_scopes;
    8787                        // create rollback
    88                         prevScope = std::make_shared<Indexer>( * this );
     88                        prevScope = std::make_shared<Indexer>( *this );
    8989                        // update repScope
    9090                        repScope = scope;
    … …  
    9595                ++scope;
    9696
    97                 ++* stats().new_scopes;
     97                ++*stats().new_scopes;
    9898                stats().avg_scope_depth->push( scope );
    9999                stats().max_scope_depth->push( scope );
    … …  
    103103                if ( repScope == scope ) {
    104104                        Ptr prev = prevScope;           // make sure prevScope stays live
    105                         * this = std::move(* prevScope);  // replace with previous scope
     105                        *this = std::move(*prevScope);  // replace with previous scope
    106106                }
    107107
    … …  
    109109        }
    110110
    111         void Indexer::lookupId( const std::string & id, std::list< IdData > &out ) const {
    112                 ++* stats().lookup_calls;
     111        void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
     112                ++*stats().lookup_calls;
    113113                if ( ! idTable ) return;
    114114
    115                 ++* stats().map_lookups;
     115                ++*stats().map_lookups;
    116116                auto decls = idTable->find( id );
    117117                if ( decls == idTable->end() ) return;
    … …  
    122122        }
    123123
    124         const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const { return lookupMutableType(id); }
    125         NamedTypeDecl * Indexer::lookupMutableType( const std::string & id ) const {
    126                 ++* stats().lookup_calls;
     124        NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
     125                ++*stats().lookup_calls;
    127126                if ( ! typeTable ) return nullptr;
    128                 ++* stats().map_lookups;
     127                ++*stats().map_lookups;
    129128                auto it = typeTable->find( id );
    130129                return it == typeTable->end() ? nullptr : it->second.decl;
    131130        }
    132131
    133         const StructDecl * Indexer::lookupStruct( const std::string & id ) const { return lookupMutableStruct(id); }
    134         StructDecl * Indexer::lookupMutableStruct( const std::string & id ) const {
    135                 ++* stats().lookup_calls;
     132        StructDecl *Indexer::lookupStruct( const std::string &id ) const {
     133                ++*stats().lookup_calls;
    136134                if ( ! structTable ) return nullptr;
    137                 ++* stats().map_lookups;
     135                ++*stats().map_lookups;
    138136                auto it = structTable->find( id );
    139137                return it == structTable->end() ? nullptr : it->second.decl;
    140138        }
    141139
    142         const EnumDecl * Indexer::lookupEnum( const std::string & id ) const { return lookupMutableEnum(id); }
    143         EnumDecl * Indexer::lookupMutableEnum( const std::string & id ) const {
    144                 ++* stats().lookup_calls;
     140        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
     141                ++*stats().lookup_calls;
    145142                if ( ! enumTable ) return nullptr;
    146                 ++* stats().map_lookups;
     143                ++*stats().map_lookups;
    147144                auto it = enumTable->find( id );
    148145                return it == enumTable->end() ? nullptr : it->second.decl;
    149146        }
    150147
    151         const UnionDecl * Indexer::lookupUnion( const std::string & id ) const { return lookupMutableUnion(id); }
    152         UnionDecl * Indexer::lookupMutableUnion( const std::string & id ) const {
    153                 ++* stats().lookup_calls;
     148        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
     149                ++*stats().lookup_calls;
    154150                if ( ! unionTable ) return nullptr;
    155                 ++* stats().map_lookups;
     151                ++*stats().map_lookups;
    156152                auto it = unionTable->find( id );
    157153                return it == unionTable->end() ? nullptr : it->second.decl;
    158154        }
    159155
    160         const TraitDecl * Indexer::lookupTrait( const std::string & id ) const { return lookupMutableTrait(id); }
    161         TraitDecl * Indexer::lookupMutableTrait( const std::string & id ) const {
    162                 ++* stats().lookup_calls;
     156        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
     157                ++*stats().lookup_calls;
    163158                if ( ! traitTable ) return nullptr;
    164                 ++* stats().map_lookups;
     159                ++*stats().map_lookups;
    165160                auto it = traitTable->find( id );
    166161                return it == traitTable->end() ? nullptr : it->second.decl;
    167162        }
    168163
    169         const Indexer * Indexer::atScope( unsigned long target ) const {
     164        const Indexer* Indexer::atScope( unsigned long target ) const {
    170165                // by lazy construction, final indexer in list has repScope 0, cannot be > target
    171166                // otherwise, will find first scope representing the target
    172                 const Indexer * indexer = this;
     167                const Indexer* indexer = this;
    173168                while ( indexer->repScope > target ) {
    174169                        indexer = indexer->prevScope.get();
    … …  
    177172        }
    178173
    179         const NamedTypeDecl * Indexer::globalLookupType( const std::string & id ) const {
     174        NamedTypeDecl *Indexer::globalLookupType( const std::string &id ) const {
    180175                return atScope( 0 )->lookupType( id );
    181176        }
    182177
    183         const StructDecl * Indexer::globalLookupStruct( const std::string & id ) const {
     178        StructDecl *Indexer::globalLookupStruct( const std::string &id ) const {
    184179                return atScope( 0 )->lookupStruct( id );
    185180        }
    186181
    187         const UnionDecl * Indexer::globalLookupUnion( const std::string & id ) const {
     182        UnionDecl *Indexer::globalLookupUnion( const std::string &id ) const {
    188183                return atScope( 0 )->lookupUnion( id );
    189184        }
    190185
    191         const EnumDecl * Indexer::globalLookupEnum( const std::string & id ) const {
     186        EnumDecl *Indexer::globalLookupEnum( const std::string &id ) const {
    192187                return atScope( 0 )->lookupEnum( id );
    193188        }
    … …  
    212207        }
    213208
    214 
    215         bool Indexer::addedIdConflicts(
    216                         const Indexer::IdData & existing, DeclarationWithType * added,
     209       
     210        bool Indexer::addedIdConflicts( 
     211                        const Indexer::IdData & existing, DeclarationWithType *added,
    217212                        Indexer::OnConflict handleConflicts, BaseSyntaxNode * deleteStmt ) {
    218                 // if we're giving the same name mangling to things of different types then there is
     213                // if we're giving the same name mangling to things of different types then there is 
    219214                // something wrong
    220215                assert( (isObject( added ) && isObject( existing.id ) )
    … …  
    224219                        // new definition shadows the autogenerated one, even at the same scope
    225220                        return false;
    226                 } else if ( LinkageSpec::isMangled( added->linkage )
    227                                 || ResolvExpr::typesCompatible(
     221                } else if ( LinkageSpec::isMangled( added->linkage ) 
     222                                || ResolvExpr::typesCompatible( 
    228223                                        added->get_type(), existing.id->get_type(), Indexer() ) ) {
    229224
    … …  
    243238                        if ( isDefinition( added ) && isDefinition( existing.id ) ) {
    244239                                if ( handleConflicts.mode == OnConflict::Error ) {
    245                                         SemanticError( added,
    246                                                 isFunction( added ) ?
    247                                                         "duplicate function definition for " :
     240                                        SemanticError( added, 
     241                                                isFunction( added ) ? 
     242                                                        "duplicate function definition for " : 
    248243                                                        "duplicate object definition for " );
    249244                                }
    … …  
    260255        }
    261256
    262         bool Indexer::hasCompatibleCDecl( const std::string & id, const std::string &mangleName ) const {
     257        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const {
    263258                if ( ! idTable ) return false;
    264259
    265                 ++* stats().map_lookups;
     260                ++*stats().map_lookups;
    266261                auto decls = idTable->find( id );
    267262                if ( decls == idTable->end() ) return false;
    … …  
    275270                        }
    276271                }
    277 
     272               
    278273                return false;
    279274        }
    280275
    281         bool Indexer::hasIncompatibleCDecl(
    282                         const std::string & id, const std::string &mangleName ) const {
     276        bool Indexer::hasIncompatibleCDecl( 
     277                        const std::string &id, const std::string &mangleName ) const {
    283278                if ( ! idTable ) return false;
    284279
    285                 ++* stats().map_lookups;
     280                ++*stats().map_lookups;
    286281                auto decls = idTable->find( id );
    287282                if ( decls == idTable->end() ) return false;
    … …  
    300295
    301296        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
    302         std::string getOtypeKey( FunctionDecl * function ) {
     297        std::string getOtypeKey( FunctionDecl* function ) {
    303298                auto& params = function->type->parameters;
    304299                assert( ! params.empty() );
    305300                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    306                 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
     301                Type* base = InitTweak::getPointerBase( params.front()->get_type() );
    307302                assert( base );
    308303                return Mangler::mangle( base );
    309304        }
    310305
    311         /// gets the declaration for the function acting on a type specified by otype key,
     306        /// gets the declaration for the function acting on a type specified by otype key, 
    312307        /// nullptr if none such
    313308        FunctionDecl * getFunctionForOtype( DeclarationWithType * decl, const std::string& otypeKey ) {
    … …  
    317312        }
    318313
    319         bool Indexer::removeSpecialOverrides(
     314        bool Indexer::removeSpecialOverrides( 
    320315                        Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
    321                 // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
    322                 // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular,
    323                 // if the user defines a default ctor, then the generated default ctor is unavailable,
    324                 // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
    325                 // field ctors are available. If the user defines any ctor then the generated default ctor
    326                 // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
    327                 // anything that looks like a copy constructor, then the generated copy constructor is
     316                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which 
     317                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular, 
     318                // if the user defines a default ctor, then the generated default ctor is unavailable, 
     319                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated 
     320                // field ctors are available. If the user defines any ctor then the generated default ctor 
     321                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines 
     322                // anything that looks like a copy constructor, then the generated copy constructor is 
    328323                // unavailable, and likewise for the assignment operator.
    329324
    … …  
    345340                        std::vector< MangleTable::value_type > deleted;
    346341                        bool alreadyUserDefinedFunc = false;
    347 
    348                         for ( const auto& entry : * mangleTable ) {
     342                       
     343                        for ( const auto& entry : *mangleTable ) {
    349344                                // skip decls that aren't functions or are for the wrong type
    350345                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
    … …  
    373368                        // perform removals from mangle table, and deletions if necessary
    374369                        for ( const auto& key : removed ) {
    375                                 ++* stats().map_mutations;
     370                                ++*stats().map_mutations;
    376371                                mangleTable = mangleTable->erase( key );
    377372                        }
    378373                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
    379                                 ++* stats().map_mutations;
     374                                ++*stats().map_mutations;
    380375                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
    381376                        }
    … …  
    384379                        // if this is the first user-defined function, delete non-user-defined overloads
    385380                        std::vector< MangleTable::value_type > deleted;
    386 
    387                         for ( const auto& entry : * mangleTable ) {
     381                       
     382                        for ( const auto& entry : *mangleTable ) {
    388383                                // skip decls that aren't functions or are for the wrong type
    389384                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
    … …  
    407402                        // this needs to be a separate loop because of iterator invalidation
    408403                        for ( const auto& entry : deleted ) {
    409                                 ++* stats().map_mutations;
     404                                ++*stats().map_mutations;
    410405                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
    411406                        }
    … …  
    413408                        // this is an overridable generated function
    414409                        // if there already exists a matching user-defined function, delete this appropriately
    415                         for ( const auto& entry : * mangleTable ) {
     410                        for ( const auto& entry : *mangleTable ) {
    416411                                // skip decls that aren't functions or are for the wrong type
    417412                                FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
    … …  
    423418                                if ( dataIsCopyFunc ) {
    424419                                        // remove current function if exists a user-defined copy function
    425                                         // since the signatures for copy functions don't need to match exactly, using
     420                                        // since the signatures for copy functions don't need to match exactly, using 
    426421                                        // a delete statement is the wrong approach
    427422                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
    … …  
    433428                        }
    434429                }
    435 
     430               
    436431                // nothing (more) to fix, return true
    437432                return true;
    438433        }
    439434
    440         void Indexer::addId(
    441                         DeclarationWithType * decl, OnConflict handleConflicts, Expression * baseExpr,
     435        void Indexer::addId( 
     436                        DeclarationWithType *decl, OnConflict handleConflicts, Expression * baseExpr,
    442437                        BaseSyntaxNode * deleteStmt ) {
    443                 ++* stats().add_calls;
     438                ++*stats().add_calls;
    444439                const std::string &name = decl->name;
    445440                if ( name == "" ) return;
    446 
     441               
    447442                std::string mangleName;
    448443                if ( LinkageSpec::isOverridable( decl->linkage ) ) {
    449                         // mangle the name without including the appropriate suffix, so overridable routines
     444                        // mangle the name without including the appropriate suffix, so overridable routines 
    450445                        // are placed into the same "bucket" as their user defined versions.
    451446                        mangleName = Mangler::mangle( decl, false );
    … …  
    454449                } // if
    455450
    456                 // this ensures that no two declarations with the same unmangled name at the same scope
     451                // this ensures that no two declarations with the same unmangled name at the same scope 
    457452                // both have C linkage
    458453                if ( LinkageSpec::isMangled( decl->linkage ) ) {
    … …  
    462457                        }
    463458                } else {
    464                         // NOTE: only correct if name mangling is completely isomorphic to C
     459                        // NOTE: only correct if name mangling is completely isomorphic to C 
    465460                        // type-compatibility, which it may not be.
    466461                        if ( hasIncompatibleCDecl( name, mangleName ) ) {
    … …  
    475470                        mangleTable = MangleTable::new_ptr();
    476471                } else {
    477                         ++* stats().map_lookups;
     472                        ++*stats().map_lookups;
    478473                        auto decls = idTable->find( name );
    479474                        if ( decls == idTable->end() ) {
    … …  
    482477                                mangleTable = decls->second;
    483478                                // skip in-scope repeat declarations of same identifier
    484                                 ++* stats().map_lookups;
     479                                ++*stats().map_lookups;
    485480                                auto existing = mangleTable->find( mangleName );
    486481                                if ( existing != mangleTable->end()
    … …  
    491486                                                        // set delete expression for conflicting identifier
    492487                                                        lazyInitScope();
    493                                                         * stats().map_mutations += 2;
     488                                                        *stats().map_mutations += 2;
    494489                                                        idTable = idTable->set(
    495490                                                                name,
    496                                                                 mangleTable->set(
    497                                                                         mangleName,
     491                                                                mangleTable->set( 
     492                                                                        mangleName, 
    498493                                                                        IdData{ existing->second, handleConflicts.deleteStmt } ) );
    499494                                                }
    … …  
    509504                // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
    510505                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
    511                 * stats().map_mutations += 2;
     506                *stats().map_mutations += 2;
    512507                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
    513508        }
    … …  
    523518        }
    524519
    525         bool addedTypeConflicts( NamedTypeDecl * existing, NamedTypeDecl * added ) {
     520        bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
    526521                if ( existing->base == nullptr ) {
    527522                        return false;
    … …  
    535530                        }
    536531                }
    537                 // does not need to be added to the table if both existing and added have a base that are
     532                // does not need to be added to the table if both existing and added have a base that are 
    538533                // the same
    539534                return true;
    540535        }
    541536
    542         void Indexer::addType( NamedTypeDecl * decl ) {
    543                 ++* stats().add_calls;
    544                 const std::string & id = decl->name;
    545 
    546                 if ( ! typeTable ) {
     537        void Indexer::addType( NamedTypeDecl *decl ) {
     538                ++*stats().add_calls;
     539                const std::string &id = decl->name;
     540
     541                if ( ! typeTable ) { 
    547542                        typeTable = TypeTable::new_ptr();
    548543                } else {
    549                         ++* stats().map_lookups;
     544                        ++*stats().map_lookups;
    550545                        auto existing = typeTable->find( id );
    551                         if ( existing != typeTable->end()
    552                                 && existing->second.scope == scope
     546                        if ( existing != typeTable->end() 
     547                                && existing->second.scope == scope 
    553548                                && addedTypeConflicts( existing->second.decl, decl ) ) return;
    554549                }
    555 
     550               
    556551                lazyInitScope();
    557                 ++* stats().map_mutations;
     552                ++*stats().map_mutations;
    558553                typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
    559554        }
    560555
    561         bool addedDeclConflicts( AggregateDecl * existing, AggregateDecl * added ) {
     556        bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
    562557                if ( ! existing->body ) {
    563558                        return false;
    … …  
    568563        }
    569564
    570         void Indexer::addStruct( const std::string & id ) {
     565        void Indexer::addStruct( const std::string &id ) {
    571566                addStruct( new StructDecl( id ) );
    572567        }
    573568
    574         void Indexer::addStruct( StructDecl * decl ) {
    575                 ++* stats().add_calls;
    576                 const std::string & id = decl->name;
     569        void Indexer::addStruct( StructDecl *decl ) {
     570                ++*stats().add_calls;
     571                const std::string &id = decl->name;
    577572
    578573                if ( ! structTable ) {
    579574                        structTable = StructTable::new_ptr();
    580575                } else {
    581                         ++* stats().map_lookups;
     576                        ++*stats().map_lookups;
    582577                        auto existing = structTable->find( id );
    583                         if ( existing != structTable->end()
    584                                 && existing->second.scope == scope
     578                        if ( existing != structTable->end() 
     579                                && existing->second.scope == scope 
    585580                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
    586581                }
    587582
    588583                lazyInitScope();
    589                 ++* stats().map_mutations;
     584                ++*stats().map_mutations;
    590585                structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
    591586        }
    592587
    593         void Indexer::addEnum( EnumDecl * decl ) {
    594                 ++* stats().add_calls;
    595                 const std::string & id = decl->name;
     588        void Indexer::addEnum( EnumDecl *decl ) {
     589                ++*stats().add_calls;
     590                const std::string &id = decl->name;
    596591
    597592                if ( ! enumTable ) {
    598593                        enumTable = EnumTable::new_ptr();
    599594                } else {
    600                         ++* stats().map_lookups;
     595                        ++*stats().map_lookups;
    601596                        auto existing = enumTable->find( id );
    602                         if ( existing != enumTable->end()
    603                                 && existing->second.scope == scope
     597                        if ( existing != enumTable->end() 
     598                                && existing->second.scope == scope 
    604599                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
    605600                }
    606 
     601               
    607602                lazyInitScope();
    608                 ++* stats().map_mutations;
     603                ++*stats().map_mutations;
    609604                enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
    610605        }
    611606
    612         void Indexer::addUnion( const std::string & id ) {
     607        void Indexer::addUnion( const std::string &id ) {
    613608                addUnion( new UnionDecl( id ) );
    614609        }
    615610
    616         void Indexer::addUnion( UnionDecl * decl ) {
    617                 ++* stats().add_calls;
    618                 const std::string & id = decl->name;
     611        void Indexer::addUnion( UnionDecl *decl ) {
     612                ++*stats().add_calls;
     613                const std::string &id = decl->name;
    619614
    620615                if ( ! unionTable ) {
    621616                        unionTable = UnionTable::new_ptr();
    622617                } else {
    623                         ++* stats().map_lookups;
     618                        ++*stats().map_lookups;
    624619                        auto existing = unionTable->find( id );
    625                         if ( existing != unionTable->end()
    626                                 && existing->second.scope == scope
     620                        if ( existing != unionTable->end() 
     621                                && existing->second.scope == scope 
    627622                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
    628623                }
    629624
    630625                lazyInitScope();
    631                 ++* stats().map_mutations;
     626                ++*stats().map_mutations;
    632627                unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
    633628        }
    634629
    635         void Indexer::addTrait( TraitDecl * decl ) {
    636                 ++* stats().add_calls;
    637                 const std::string & id = decl->name;
     630        void Indexer::addTrait( TraitDecl *decl ) {
     631                ++*stats().add_calls;
     632                const std::string &id = decl->name;
    638633
    639634                if ( ! traitTable ) {
    640635                        traitTable = TraitTable::new_ptr();
    641636                } else {
    642                         ++* stats().map_lookups;
     637                        ++*stats().map_lookups;
    643638                        auto existing = traitTable->find( id );
    644                         if ( existing != traitTable->end()
    645                                 && existing->second.scope == scope
     639                        if ( existing != traitTable->end() 
     640                                && existing->second.scope == scope 
    646641                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
    647642                }
    648643
    649644                lazyInitScope();
    650                 ++* stats().map_mutations;
     645                ++*stats().map_mutations;
    651646                traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
    652647        }
    653648
    654         void Indexer::addMembers( AggregateDecl * aggr, Expression * expr,
     649        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, 
    655650                        OnConflict handleConflicts ) {
    656651                for ( Declaration * decl : aggr->members ) {
    … …  
    659654                                if ( dwt->name == "" ) {
    660655                                        Type * t = dwt->get_type()->stripReferences();
    661                                         if ( dynamic_cast<StructInstType *>( t ) || dynamic_cast<UnionInstType *>( t ) ) {
     656                                        if ( dynamic_cast<StructInstType*>( t ) || dynamic_cast<UnionInstType*>( t ) ) {
    662657                                                Expression * base = expr->clone();
    663658                                                ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?

  • src/SymTab/Indexer.h

    rfce4e31 r302d84c2  
    3434                virtual ~Indexer();
    3535
    36                 // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
     36                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to 
    3737                // tell the indexer explicitly when scopes begin and end
    3838                void enterScope();
    … …  
    5050                        // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
    5151                        IdData() = default;
    52                         IdData(
     52                        IdData( 
    5353                                DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt,
    54                                 unsigned long scope )
     54                                unsigned long scope ) 
    5555                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
    5656                        IdData( const IdData& o, BaseSyntaxNode * deleteStmt )
    … …  
    6161
    6262                /// Gets all declarations with the given ID
    63                 void lookupId( const std::string & id, std::list< IdData > &out ) const;
     63                void lookupId( const std::string &id, std::list< IdData > &out ) const;
    6464                /// Gets the top-most type declaration with the given ID
    65                 const NamedTypeDecl * lookupType( const std::string & id ) const;
    66                 NamedTypeDecl * lookupMutableType( const std::string & id ) const;
     65                NamedTypeDecl *lookupType( const std::string &id ) const;
    6766                /// Gets the top-most struct declaration with the given ID
    68                 const StructDecl * lookupStruct( const std::string & id ) const;
    69                 StructDecl * lookupMutableStruct( const std::string & id ) const;
     67                StructDecl *lookupStruct( const std::string &id ) const;
    7068                /// Gets the top-most enum declaration with the given ID
    71                 const EnumDecl * lookupEnum( const std::string & id ) const;
    72                 EnumDecl * lookupMutableEnum( const std::string & id ) const;
     69                EnumDecl *lookupEnum( const std::string &id ) const;
    7370                /// Gets the top-most union declaration with the given ID
    74                 const UnionDecl * lookupUnion( const std::string & id ) const;
    75                 UnionDecl * lookupMutableUnion( const std::string & id ) const;
     71                UnionDecl *lookupUnion( const std::string &id ) const;
    7672                /// Gets the top-most trait declaration with the given ID
    77                 const TraitDecl * lookupTrait( const std::string & id ) const;
    78                 TraitDecl * lookupMutableTrait( const std::string & id ) const;
     73                TraitDecl *lookupTrait( const std::string &id ) const;
    7974
    8075                /// Gets the type declaration with the given ID at global scope
    81                 const NamedTypeDecl * globalLookupType( const std::string & id ) const;
     76                NamedTypeDecl *globalLookupType( const std::string &id ) const;
    8277                /// Gets the struct declaration with the given ID at global scope
    83                 const StructDecl * globalLookupStruct( const std::string & id ) const;
     78                StructDecl *globalLookupStruct( const std::string &id ) const;
    8479                /// Gets the union declaration with the given ID at global scope
    85                 const UnionDecl * globalLookupUnion( const std::string & id ) const;
     80                UnionDecl *globalLookupUnion( const std::string &id ) const;
    8681                /// Gets the enum declaration with the given ID at global scope
    87                 const EnumDecl * globalLookupEnum( const std::string & id ) const;
     82                EnumDecl *globalLookupEnum( const std::string &id ) const;
    8883
    8984                void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
    9085                void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );
    9186
    92                 void addType( NamedTypeDecl * decl );
    93                 void addStruct( const std::string & id );
    94                 void addStruct( StructDecl * decl );
    95                 void addEnum( EnumDecl * decl );
    96                 void addUnion( const std::string & id );
    97                 void addUnion( UnionDecl * decl );
    98                 void addTrait( TraitDecl * decl );
     87                void addType( NamedTypeDecl *decl );
     88                void addStruct( const std::string &id );
     89                void addStruct( StructDecl *decl );
     90                void addEnum( EnumDecl *decl );
     91                void addUnion( const std::string &id );
     92                void addUnion( UnionDecl *decl );
     93                void addTrait( TraitDecl *decl );
    9994
    10095                /// adds all of the IDs from WithStmt exprs
    … …  
    111106
    112107          private:
    113                 /// Wraps a Decl * with a scope
     108                /// Wraps a Decl* with a scope
    114109                template<typename Decl>
    115110                struct Scoped {
    116                         Decl * decl;           ///< declaration
     111                        Decl* decl;           ///< declaration
    117112                        unsigned long scope;  ///< scope of this declaration
    118113
    119                         Scoped(Decl * d, unsigned long s) : decl(d), scope(s) {}
     114                        Scoped(Decl* d, unsigned long s) : decl(d), scope(s) {}
    120115                };
    121116
    … …  
    145140
    146141                /// Gets the indexer at the given scope
    147                 const Indexer * atScope( unsigned long scope ) const;
     142                const Indexer* atScope( unsigned long scope ) const;
    148143
    149                 /// Removes matching autogenerated constructors and destructors so that they will not be
     144                /// Removes matching autogenerated constructors and destructors so that they will not be 
    150145                /// selected. If returns false, passed decl should not be added.
    151146                bool removeSpecialOverrides( IdData& decl, MangleTable::Ptr& mangleTable );
    … …  
    171166                /// true if the existing identifier conflicts with the added identifier
    172167                bool addedIdConflicts(
    173                         const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts,
     168                        const IdData& existing, DeclarationWithType * added, OnConflict handleConflicts, 
    174169                        BaseSyntaxNode * deleteStmt );
    175170
    176171                /// common code for addId, addDeletedId, etc.
    177                 void addId(
    178                         DeclarationWithType * decl, OnConflict handleConflicts,
     172                void addId( 
     173                        DeclarationWithType * decl, OnConflict handleConflicts, 
    179174                        Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
    180175
    … …  
    183178
    184179                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
    185                 bool hasCompatibleCDecl( const std::string & id, const std::string &mangleName ) const;
     180                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
    186181                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
    187                 bool hasIncompatibleCDecl( const std::string & id, const std::string &mangleName ) const;
     182                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const;
    188183        };
    189184} // namespace SymTab

  • src/SymTab/Validate.cc

    rfce4e31 r302d84c2  
    119119
    120120          private:
    121                 template< typename AggDecl > void handleAggregate( AggDecl * aggregateDecl );
     121                template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
    122122
    123123                AggregateDecl * parentAggr = nullptr;
    … …  
    134134        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
    135135        struct EnumAndPointerDecay_old {
    136                 void previsit( EnumDecl * aggregateDecl );
    137                 void previsit( FunctionType * func );
     136                void previsit( EnumDecl *aggregateDecl );
     137                void previsit( FunctionType *func );
    138138        };
    139139
    140140        /// Associates forward declarations of aggregates with their definitions
    141141        struct LinkReferenceToTypes_old final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes_old>, public WithShortCircuiting {
    142                 LinkReferenceToTypes_old( const Indexer * indexer );
    143                 void postvisit( TypeInstType * typeInst );
    144 
    145                 void postvisit( EnumInstType * enumInst );
    146                 void postvisit( StructInstType * structInst );
    147                 void postvisit( UnionInstType * unionInst );
    148                 void postvisit( TraitInstType * traitInst );
     142                LinkReferenceToTypes_old( const Indexer *indexer );
     143                void postvisit( TypeInstType *typeInst );
     144
     145                void postvisit( EnumInstType *enumInst );
     146                void postvisit( StructInstType *structInst );
     147                void postvisit( UnionInstType *unionInst );
     148                void postvisit( TraitInstType *traitInst );
    149149                void previsit( QualifiedType * qualType );
    150150                void postvisit( QualifiedType * qualType );
    151151
    152                 void postvisit( EnumDecl * enumDecl );
    153                 void postvisit( StructDecl * structDecl );
    154                 void postvisit( UnionDecl * unionDecl );
     152                void postvisit( EnumDecl *enumDecl );
     153                void postvisit( StructDecl *structDecl );
     154                void postvisit( UnionDecl *unionDecl );
    155155                void postvisit( TraitDecl * traitDecl );
    156156
    157                 void previsit( StructDecl * structDecl );
    158                 void previsit( UnionDecl * unionDecl );
     157                void previsit( StructDecl *structDecl );
     158                void previsit( UnionDecl *unionDecl );
    159159
    160160                void renameGenericParams( std::list< TypeDecl * > & params );
    161161
    162162          private:
    163                 const Indexer * local_indexer;
     163                const Indexer *local_indexer;
    164164
    165165                typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
    … …  
    239239
    240240                template<typename AggDecl>
    241                 void handleAggregate( AggDecl * aggregateDecl );
     241                void handleAggregate( AggDecl *aggregateDecl );
    242242
    243243                void previsit( StructDecl * aggregateDecl );
    … …  
    252252                static void verify( std::list< Declaration * > &translationUnit );
    253253
    254                 void previsit( FunctionDecl * funcDecl );
     254                void previsit( FunctionDecl *funcDecl );
    255255        };
    256256
    … …  
    287287                Type::StorageClasses storageClasses;
    288288
    289                 void premutate( ObjectDecl * objectDecl );
    290                 Expression * postmutate( CompoundLiteralExpr * compLitExpr );
     289                void premutate( ObjectDecl *objectDecl );
     290                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
    291291        };
    292292
    … …  
    393393        }
    394394
    395         void validateType( Type * type, const Indexer * indexer ) {
     395        void validateType( Type *type, const Indexer *indexer ) {
    396396                PassVisitor<EnumAndPointerDecay_old> epc;
    397397                PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
    … …  
    496496        }
    497497
    498         bool shouldHoist( Declaration * decl ) {
     498        bool shouldHoist( Declaration *decl ) {
    499499                return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl ) || dynamic_cast< StaticAssertDecl * >( decl );
    500500        }
    … …  
    515515
    516516        template< typename AggDecl >
    517         void HoistStruct::handleAggregate( AggDecl * aggregateDecl ) {
     517        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
    518518                if ( parentAggr ) {
    519519                        aggregateDecl->parent = parentAggr;
    … …  
    560560
    561561
    562         bool isTypedef( Declaration * decl ) {
     562        bool isTypedef( Declaration *decl ) {
    563563                return dynamic_cast< TypedefDecl * >( decl );
    564564        }
    … …  
    571571
    572572        template< typename AggDecl >
    573         void EliminateTypedef::handleAggregate( AggDecl * aggregateDecl ) {
     573        void EliminateTypedef::handleAggregate( AggDecl *aggregateDecl ) {
    574574                filter( aggregateDecl->members, isTypedef, true );
    575575        }
    … …  
    586586                // remove and delete decl stmts
    587587                filter( compoundStmt->kids, [](Statement * stmt) {
    588                         if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
     588                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
    589589                                if ( dynamic_cast< TypedefDecl * >( declStmt->decl ) ) {
    590590                                        return true;
    … …  
    595595        }
    596596
    597         void EnumAndPointerDecay_old::previsit( EnumDecl * enumDecl ) {
     597        void EnumAndPointerDecay_old::previsit( EnumDecl *enumDecl ) {
    598598                // Set the type of each member of the enumeration to be EnumConstant
    599599                for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
    600                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( * i );
     600                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
    601601                        assert( obj );
    602602                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
    … …  
    627627        }
    628628
    629         void EnumAndPointerDecay_old::previsit( FunctionType * func ) {
     629        void EnumAndPointerDecay_old::previsit( FunctionType *func ) {
    630630                // Fix up parameters and return types
    631631                fixFunctionList( func->parameters, func->isVarArgs, func );
    … …  
    633633        }
    634634
    635         LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) {
     635        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer *other_indexer ) {
    636636                if ( other_indexer ) {
    637637                        local_indexer = other_indexer;
    … …  
    641641        }
    642642
    643         void LinkReferenceToTypes_old::postvisit( EnumInstType * enumInst ) {
    644                 EnumDecl * st = local_indexer->lookupMutableEnum( enumInst->name );
     643        void LinkReferenceToTypes_old::postvisit( EnumInstType *enumInst ) {
     644                EnumDecl *st = local_indexer->lookupEnum( enumInst->name );
    645645                // it's not a semantic error if the enum is not found, just an implicit forward declaration
    646646                if ( st ) {
    … …  
    661661        }
    662662
    663         void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
    664                 StructDecl * st = local_indexer->lookupMutableStruct( structInst->name );
     663        void LinkReferenceToTypes_old::postvisit( StructInstType *structInst ) {
     664                StructDecl *st = local_indexer->lookupStruct( structInst->name );
    665665                // it's not a semantic error if the struct is not found, just an implicit forward declaration
    666666                if ( st ) {
    … …  
    674674        }
    675675
    676         void LinkReferenceToTypes_old::postvisit( UnionInstType * unionInst ) {
    677                 UnionDecl * un = local_indexer->lookupMutableUnion( unionInst->name );
     676        void LinkReferenceToTypes_old::postvisit( UnionInstType *unionInst ) {
     677                UnionDecl *un = local_indexer->lookupUnion( unionInst->name );
    678678                // it's not a semantic error if the union is not found, just an implicit forward declaration
    679679                if ( un ) {
    … …  
    693693        void LinkReferenceToTypes_old::postvisit( QualifiedType * qualType ) {
    694694                // linking only makes sense for the 'oldest ancestor' of the qualified type
    695                 qualType->parent->accept( * visitor );
     695                qualType->parent->accept( *visitor );
    696696        }
    697697
    … …  
    762762        void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
    763763                // handle other traits
    764                 TraitDecl * traitDecl = local_indexer->lookupMutableTrait( traitInst->name );
     764                TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
    765765                if ( ! traitDecl ) {
    766766                        SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
    … …  
    786786        }
    787787
    788         void LinkReferenceToTypes_old::postvisit( EnumDecl * enumDecl ) {
     788        void LinkReferenceToTypes_old::postvisit( EnumDecl *enumDecl ) {
    789789                // visit enum members first so that the types of self-referencing members are updated properly
    790790                if ( enumDecl->body ) {
    … …  
    792792                        if ( fwds != forwardEnums.end() ) {
    793793                                for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    794                                         (* inst)->baseEnum = enumDecl;
     794                                        (*inst)->baseEnum = enumDecl;
    795795                                } // for
    796796                                forwardEnums.erase( fwds );
    … …  
    834834        }
    835835
    836         void LinkReferenceToTypes_old::postvisit( StructDecl * structDecl ) {
     836        void LinkReferenceToTypes_old::postvisit( StructDecl *structDecl ) {
    837837                // visit struct members first so that the types of self-referencing members are updated properly
    838838                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
    … …  
    841841                        if ( fwds != forwardStructs.end() ) {
    842842                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    843                                         (* inst)->baseStruct = structDecl;
     843                                        (*inst)->baseStruct = structDecl;
    844844                                } // for
    845845                                forwardStructs.erase( fwds );
    … …  
    848848        }
    849849
    850         void LinkReferenceToTypes_old::postvisit( UnionDecl * unionDecl ) {
     850        void LinkReferenceToTypes_old::postvisit( UnionDecl *unionDecl ) {
    851851                if ( unionDecl->body ) {
    852852                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
    853853                        if ( fwds != forwardUnions.end() ) {
    854854                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    855                                         (* inst)->baseUnion = unionDecl;
     855                                        (*inst)->baseUnion = unionDecl;
    856856                                } // for
    857857                                forwardUnions.erase( fwds );
    … …  
    860860        }
    861861
    862         void LinkReferenceToTypes_old::postvisit( TypeInstType * typeInst ) {
     862        void LinkReferenceToTypes_old::postvisit( TypeInstType *typeInst ) {
    863863                // ensure generic parameter instances are renamed like the base type
    864864                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
    865                 if ( const NamedTypeDecl * namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
    866                         if ( const TypeDecl * typeDecl = dynamic_cast< const TypeDecl * >( namedTypeDecl ) ) {
    867                                 typeInst->set_isFtype( typeDecl->kind == TypeDecl::Ftype );
     865                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
     866                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
     867                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
    868868                        } // if
    869869                } // if
    … …  
    877877                        // expand trait instances into their members
    878878                        for ( DeclarationWithType * assertion : asserts ) {
    879                                 if ( TraitInstType * traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
     879                                if ( TraitInstType *traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
    880880                                        // expand trait instance into all of its members
    881881                                        expandAssertions( traitInst, back_inserter( type->assertions ) );
    … …  
    897897        }
    898898
    899         void ForallPointerDecay_old::previsit( ObjectDecl * object ) {
     899        void ForallPointerDecay_old::previsit( ObjectDecl *object ) {
    900900                // ensure that operator names only apply to functions or function pointers
    901901                if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
    … …  
    905905        }
    906906
    907         void ForallPointerDecay_old::previsit( FunctionDecl * func ) {
     907        void ForallPointerDecay_old::previsit( FunctionDecl *func ) {
    908908                func->fixUniqueId();
    909909        }
    … …  
    961961        Type * ReplaceTypedef::postmutate( QualifiedType * qualType ) {
    962962                // replacing typedefs only makes sense for the 'oldest ancestor' of the qualified type
    963                 qualType->parent = qualType->parent->acceptMutator( * visitor );
     963                qualType->parent = qualType->parent->acceptMutator( *visitor );
    964964                return qualType;
    965965        }
    … …  
    970970                TypedefMap::const_iterator def = typedefNames.find( typeInst->name );
    971971                if ( def != typedefNames.end() ) {
    972                         Type * ret = def->second.first->base->clone();
     972                        Type *ret = def->second.first->base->clone();
    973973                        ret->location = typeInst->location;
    974974                        ret->get_qualifiers() |= typeInst->get_qualifiers();
    … …  
    982982                        // place instance parameters on the typedef'd type
    983983                        if ( ! typeInst->parameters.empty() ) {
    984                                 ReferenceToType * rtt = dynamic_cast<ReferenceToType *>(ret);
     984                                ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
    985985                                if ( ! rtt ) {
    986986                                        SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
    … …  
    988988                                rtt->parameters.clear();
    989989                                cloneAll( typeInst->parameters, rtt->parameters );
    990                                 mutateAll( rtt->parameters, * visitor );  // recursively fix typedefs on parameters
     990                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
    991991                        } // if
    992992                        delete typeInst;
    … …  
    10431043                //    struct screen;
    10441044                // because the expansion of the typedef is:
    1045                 //    void rtn( SCREEN * p ) => void rtn( struct screen * p )
     1045                //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
    10461046                // hence the type-name "screen" must be defined.
    10471047                // Note, qualifiers on the typedef are superfluous for the forward declaration.
    10481048
    1049                 Type * designatorType = tyDecl->base->stripDeclarator();
    1050                 if ( StructInstType * aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
     1049                Type *designatorType = tyDecl->base->stripDeclarator();
     1050                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
    10511051                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
    1052                 } else if ( UnionInstType * aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
     1052                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
    10531053                        declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
    1054                 } else if ( EnumInstType * enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
     1054                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
    10551055                        declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
    10561056                } // if
    … …  
    10781078
    10791079        DeclarationWithType * ReplaceTypedef::postmutate( ObjectDecl * objDecl ) {
    1080                 if ( FunctionType * funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
     1080                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
    10811081                        // replace the current object declaration with a function declaration
    10821082                        FunctionDecl * newDecl = new FunctionDecl( objDecl->name, objDecl->get_storageClasses(), objDecl->linkage, funtype, 0, objDecl->attributes, objDecl->get_funcSpec() );
    … …  
    11041104        void ReplaceTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
    11051105                if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
    1106                         Type * type = nullptr;
     1106                        Type *type = nullptr;
    11071107                        if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
    11081108                                type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
    … …  
    11301130                GuardScope( typedefNames );
    11311131                GuardScope( typedeclNames );
    1132                 mutateAll( aggr->parameters, * visitor );
     1132                mutateAll( aggr->parameters, *visitor );
    11331133
    11341134                // unroll mutateAll for aggr->members so that implicit typedefs for nested types are added to the aggregate body.
    … …  
    11371137
    11381138                        try {
    1139                                 * i = maybeMutate( * i, * visitor );
     1139                                *i = maybeMutate( *i, *visitor );
    11401140                        } catch ( SemanticErrorException &e ) {
    11411141                                errors.append( e );
    … …  
    12171217                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
    12181218                                if ( i < args.size() ) {
    1219                                         TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( * std::next( args.begin(), i ) );
    1220                                         sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
     1219                                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
     1220                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
    12211221                                } else if ( i == args.size() ) {
    1222                                         Type * defaultType = (* paramIter)->get_init();
     1222                                        Type * defaultType = (*paramIter)->get_init();
    12231223                                        if ( defaultType ) {
    12241224                                                args.push_back( new TypeExpr( defaultType->clone() ) );
    1225                                                 sub.add( (* paramIter)->get_name(), defaultType->clone() );
     1225                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
    12261226                                        }
    12271227                                }
    … …  
    12421242        }
    12431243
    1244         void CompoundLiteral::premutate( ObjectDecl * objectDecl ) {
     1244        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
    12451245                storageClasses = objectDecl->get_storageClasses();
    12461246        }
    12471247
    1248         Expression * CompoundLiteral::postmutate( CompoundLiteralExpr * compLitExpr ) {
     1248        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
    12491249                // transform [storage_class] ... (struct S){ 3, ... };
    12501250                // into [storage_class] struct S temp =  { 3, ... };
    12511251                static UniqueName indexName( "_compLit" );
    12521252
    1253                 ObjectDecl * tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
     1253                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
    12541254                compLitExpr->set_result( nullptr );
    12551255                compLitExpr->set_initializer( nullptr );
    … …  
    12891289                        TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
    12901290                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
    1291                         ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer *>(), noDesignators, false ) );
     1291                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
    12921292                        deleteAll( retVals );
    12931293                        retVals.clear();
    … …  
    13021302
    13031303        void FixObjectType::previsit( ObjectDecl * objDecl ) {
    1304                 Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
     1304                Type *new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
    13051305                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    13061306                objDecl->set_type( new_type );
    … …  
    13081308
    13091309        void FixObjectType::previsit( FunctionDecl * funcDecl ) {
    1310                 Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
     1310                Type *new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
    13111311                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    13121312                funcDecl->set_type( new_type );
    13131313        }
    13141314
    1315         void FixObjectType::previsit( TypeDecl * typeDecl ) {
     1315        void FixObjectType::previsit( TypeDecl *typeDecl ) {
    13161316                if ( typeDecl->get_base() ) {
    1317                         Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
     1317                        Type *new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
    13181318                        new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
    13191319                        typeDecl->set_base( new_type );
    … …  
    13781378
    13791379namespace {
    1380         /// Replaces enum types by int, and function/array types in function parameter and return
     1380        /// Replaces enum types by int, and function/array types in function parameter and return 
    13811381        /// lists by appropriate pointers
    13821382        struct EnumAndPointerDecay_new {
    … …  
    13851385                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
    13861386                                // build new version of object with EnumConstant
    1387                                 ast::ptr< ast::ObjectDecl > obj =
     1387                                ast::ptr< ast::ObjectDecl > obj = 
    13881388                                        enumDecl->members[i].strict_as< ast::ObjectDecl >();
    1389                                 obj.get_and_mutate()->type =
     1389                                obj.get_and_mutate()->type = 
    13901390                                        new ast::EnumInstType{ enumDecl->name, ast::CV::Const };
    1391 
     1391                               
    13921392                                // set into decl
    13931393                                ast::EnumDecl * mut = mutate( enumDecl );
    … …  
    13991399
    14001400                static const ast::FunctionType * fixFunctionList(
    1401                         const ast::FunctionType * func,
     1401                        const ast::FunctionType * func, 
    14021402                        std::vector< ast::ptr< ast::DeclWithType > > ast::FunctionType::* field,
    14031403                        ast::ArgumentFlag isVarArgs = ast::FixedArgs
    14041404                ) {
    1405                         const auto & dwts = func->* field;
     1405                        const auto & dwts = func->*field;
    14061406                        unsigned nvals = dwts.size();
    14071407                        bool hasVoid = false;
    … …  
    14091409                                func = ast::mutate_field_index( func, field, i, fixFunction( dwts[i], hasVoid ) );
    14101410                        }
    1411 
     1411                       
    14121412                        // the only case in which "void" is valid is where it is the only one in the list
    14131413                        if ( hasVoid && ( nvals > 1 || isVarArgs ) ) {
    1414                                 SemanticError(
     1414                                SemanticError( 
    14151415                                        dwts.front()->location, func, "invalid type void in function type" );
    14161416                        }
    … …  
    14181418                        // one void is the only thing in the list, remove it
    14191419                        if ( hasVoid ) {
    1420                                 func = ast::mutate_field(
     1420                                func = ast::mutate_field( 
    14211421                                        func, field, std::vector< ast::ptr< ast::DeclWithType > >{} );
    14221422                        }
    … …  
    14321432
    14331433        /// expand assertions from a trait instance, performing appropriate type variable substitutions
    1434         void expandAssertions(
    1435                 const ast::TraitInstType * inst, std::vector< ast::ptr< ast::DeclWithType > > & out
     1434        void expandAssertions( 
     1435                const ast::TraitInstType * inst, std::vector< ast::ptr< ast::DeclWithType > > & out 
    14361436        ) {
    14371437                assertf( inst->base, "Trait instance not linked to base trait: %s", toCString( inst ) );
    14381438
    14391439                // build list of trait members, substituting trait decl parameters for instance parameters
    1440                 ast::TypeSubstitution sub{
     1440                ast::TypeSubstitution sub{ 
    14411441                        inst->base->params.begin(), inst->base->params.end(), inst->params.begin() };
    14421442                // deliberately take ast::ptr by-value to ensure this does not mutate inst->base
    … …  
    14491449
    14501450        /// Associates forward declarations of aggregates with their definitions
    1451         class LinkReferenceToTypes_new final
    1452         : public ast::WithSymbolTable, public ast::WithGuards, public
     1451        class LinkReferenceToTypes_new final 
     1452        : public ast::WithSymbolTable, public ast::WithGuards, public 
    14531453          ast::WithVisitorRef<LinkReferenceToTypes_new>, public ast::WithShortCircuiting {
    1454 
    1455                 // these maps of uses of forward declarations of types need to have the actual type
    1456                 // declaration switched in * after * they have been traversed. To enable this in the
    1457                 // ast::Pass framework, any node that needs to be so mutated has mutate() called on it
    1458                 // before it is placed in the map, properly updating its parents in the usual traversal,
     1454               
     1455                // these maps of uses of forward declarations of types need to have the actual type 
     1456                // declaration switched in *after* they have been traversed. To enable this in the
     1457                // ast::Pass framework, any node that needs to be so mutated has mutate() called on it 
     1458                // before it is placed in the map, properly updating its parents in the usual traversal, 
    14591459                // then can have the actual mutation applied later
    14601460                using ForwardEnumsType = std::unordered_multimap< std::string, ast::EnumInstType * >;
    14611461                using ForwardStructsType = std::unordered_multimap< std::string, ast::StructInstType * >;
    14621462                using ForwardUnionsType = std::unordered_multimap< std::string, ast::UnionInstType * >;
    1463 
     1463               
    14641464                const CodeLocation & location;
    14651465                const ast::SymbolTable * localSymtab;
    1466 
     1466               
    14671467                ForwardEnumsType forwardEnums;
    14681468                ForwardStructsType forwardStructs;
    14691469                ForwardUnionsType forwardUnions;
    14701470
    1471                 /// true if currently in a generic type body, so that type parameter instances can be
     1471                /// true if currently in a generic type body, so that type parameter instances can be 
    14721472                /// renamed appropriately
    14731473                bool inGeneric = false;
    … …  
    14751475        public:
    14761476                /// contstruct using running symbol table
    1477                 LinkReferenceToTypes_new( const CodeLocation & loc )
     1477                LinkReferenceToTypes_new( const CodeLocation & loc ) 
    14781478                : location( loc ), localSymtab( &symtab ) {}
    1479 
     1479               
    14801480                /// construct using provided symbol table
    1481                 LinkReferenceToTypes_new( const CodeLocation & loc, const ast::SymbolTable & syms )
     1481                LinkReferenceToTypes_new( const CodeLocation & loc, const ast::SymbolTable & syms ) 
    14821482                : location( loc ), localSymtab( &syms ) {}
    14831483
    … …  
    14851485                        // ensure generic parameter instances are renamed like the base type
    14861486                        if ( inGeneric && typeInst->base ) {
    1487                                 typeInst = ast::mutate_field(
     1487                                typeInst = ast::mutate_field( 
    14881488                                        typeInst, &ast::TypeInstType::name, typeInst->base->name );
    14891489                        }
    14901490
    1491                         if (
    1492                                 auto typeDecl = dynamic_cast< const ast::TypeDecl * >(
    1493                                         localSymtab->lookupType( typeInst->name ) )
     1491                        if ( 
     1492                                auto typeDecl = dynamic_cast< const ast::TypeDecl * >( 
     1493                                        localSymtab->lookupType( typeInst->name ) ) 
    14941494                        ) {
    14951495                                typeInst = ast::mutate_field( typeInst, &ast::TypeInstType::kind, typeDecl->kind );
    … …  
    15171517                        for ( const ast::Expr * param : inst->params ) {
    15181518                                if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
    1519                                         SemanticError(
     1519                                        SemanticError( 
    15201520                                                location, inst, "Expression parameters for generic types are currently "
    15211521                                                "unsupported: " );
    … …  
    15711571                                auto expr = traitInst->params[i].as< ast::TypeExpr >();
    15721572                                if ( ! expr ) {
    1573                                         SemanticError(
     1573                                        SemanticError( 
    15741574                                                traitInst->params[i].get(), "Expression parameters for trait instances "
    15751575                                                "are currently unsupported: " );
    … …  
    15931593                        return traitInst;
    15941594                }
    1595 
     1595               
    15961596                void previsit( const ast::QualifiedType * ) { visit_children = false; }
    1597 
     1597               
    15981598                const ast::Type * postvisit( const ast::QualifiedType * qualType ) {
    15991599                        // linking only makes sense for the "oldest ancestor" of the qualified type
    1600                         return ast::mutate_field(
    1601                                 qualType, &ast::QualifiedType::parent, qualType->parent->accept( * visitor ) );
     1600                        return ast::mutate_field( 
     1601                                qualType, &ast::QualifiedType::parent, qualType->parent->accept( *visitor ) );
    16021602                }
    16031603
    16041604                const ast::Decl * postvisit( const ast::EnumDecl * enumDecl ) {
    1605                         // visit enum members first so that the types of self-referencing members are updated
     1605                        // visit enum members first so that the types of self-referencing members are updated 
    16061606                        // properly
    16071607                        if ( ! enumDecl->body ) return enumDecl;
    … …  
    16121612                                auto inst = fwds.first;
    16131613                                do {
    1614                                         // forward decl is stored * mutably * in map, can thus be updated
     1614                                        // forward decl is stored *mutably* in map, can thus be updated
    16151615                                        inst->second->base = enumDecl;
    16161616                                } while ( ++inst != fwds.second );
    16171617                                forwardEnums.erase( fwds.first, fwds.second );
    16181618                        }
    1619 
     1619                       
    16201620                        // ensure that enumerator initializers are properly set
    16211621                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
    16221622                                auto field = enumDecl->members[i].strict_as< ast::ObjectDecl >();
    16231623                                if ( field->init ) {
    1624                                         // need to resolve enumerator initializers early so that other passes that
     1624                                        // need to resolve enumerator initializers early so that other passes that 
    16251625                                        // determine if an expression is constexpr have appropriate information
    16261626                                        auto init = field->init.strict_as< ast::SingleInit >();
    1627 
    1628                                         enumDecl = ast::mutate_field_index(
    1629                                                 enumDecl, &ast::EnumDecl::members, i,
    1630                                                 ast::mutate_field( field, &ast::ObjectDecl::init,
     1627                                       
     1628                                        enumDecl = ast::mutate_field_index( 
     1629                                                enumDecl, &ast::EnumDecl::members, i, 
     1630                                                ast::mutate_field( field, &ast::ObjectDecl::init, 
    16311631                                                        ast::mutate_field( init, &ast::SingleInit::value,
    1632                                                                 ResolvExpr::findSingleExpression(
     1632                                                                ResolvExpr::findSingleExpression( 
    16331633                                                                        init->value, new ast::BasicType{ ast::BasicType::SignedInt },
    16341634                                                                        symtab ) ) ) );
    … …  
    16391639                }
    16401640
    1641                 /// rename generic type parameters uniquely so that they do not conflict with user defined
     1641                /// rename generic type parameters uniquely so that they do not conflict with user defined 
    16421642                /// function forall parameters, e.g. the T in Box and the T in f, below
    16431643                ///   forall(otype T)
    … …  
    16571657                                const ast::TypeDecl * td = aggr->params[i];
    16581658
    1659                                 aggr = ast::mutate_field_index(
    1660                                         aggr, &AggrDecl::params, i,
     1659                                aggr = ast::mutate_field_index( 
     1660                                        aggr, &AggrDecl::params, i, 
    16611661                                        ast::mutate_field( td, &ast::TypeDecl::name, "__" + td->name + "_generic_" ) );
    16621662                        }
    … …  
    16691669
    16701670                void postvisit( const ast::StructDecl * structDecl ) {
    1671                         // visit struct members first so that the types of self-referencing members are
     1671                        // visit struct members first so that the types of self-referencing members are 
    16721672                        // updated properly
    16731673                        if ( ! structDecl->body ) return;
    … …  
    16781678                                auto inst = fwds.first;
    16791679                                do {
    1680                                         // forward decl is stored * mutably * in map, can thus be updated
     1680                                        // forward decl is stored *mutably* in map, can thus be updated
    16811681                                        inst->second->base = structDecl;
    16821682                                } while ( ++inst != fwds.second );
    … …  
    16901690
    16911691                void postvisit( const ast::UnionDecl * unionDecl ) {
    1692                         // visit union members first so that the types of self-referencing members are updated
     1692                        // visit union members first so that the types of self-referencing members are updated 
    16931693                        // properly
    16941694                        if ( ! unionDecl->body ) return;
    … …  
    16991699                                auto inst = fwds.first;
    17001700                                do {
    1701                                         // forward decl is stored * mutably * in map, can thus be updated
     1701                                        // forward decl is stored *mutably* in map, can thus be updated
    17021702                                        inst->second->base = unionDecl;
    17031703                                } while ( ++inst != fwds.second );
    … …  
    17121712                                        "number of parameters: %zd", traitDecl->params.size() );
    17131713
    1714                                 traitDecl = ast::mutate_field_index(
    1715                                         traitDecl, &ast::TraitDecl::params, 0,
    1716                                         ast::mutate_field(
     1714                                traitDecl = ast::mutate_field_index( 
     1715                                        traitDecl, &ast::TraitDecl::params, 0, 
     1716                                        ast::mutate_field( 
    17171717                                                traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) );
    17181718                        }
    … …  
    17371737                                traitDecl = mut;
    17381738                        }
    1739 
     1739                       
    17401740                        return traitDecl;
    17411741                }
    17421742        };
    17431743
    1744         /// Replaces array and function types in forall lists by appropriate pointer type and assigns
     1744        /// Replaces array and function types in forall lists by appropriate pointer type and assigns 
    17451745        /// each object and function declaration a unique ID
    17461746        class ForallPointerDecay_new {
    … …  
    17511751                const ast::ObjectDecl * previsit( const ast::ObjectDecl * obj ) {
    17521752                        // ensure that operator names only apply to functions or function pointers
    1753                         if (
    1754                                 CodeGen::isOperator( obj->name )
     1753                        if ( 
     1754                                CodeGen::isOperator( obj->name ) 
    17551755                                && ! dynamic_cast< const ast::FunctionType * >( obj->type->stripDeclarator() )
    17561756                        ) {
    … …  
    17761776                /// Fix up assertions -- flattens assertion lists, removing all trait instances
    17771777                template< typename node_t, typename parent_t >
    1778                 static const node_t * forallFixer(
    1779                         const CodeLocation & loc, const node_t * node,
     1778                static const node_t * forallFixer( 
     1779                        const CodeLocation & loc, const node_t * node, 
    17801780                        ast::ParameterizedType::ForallList parent_t::* forallField
    17811781                ) {
    1782                         for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
    1783                                 const ast::TypeDecl * type = (node->* forallField)[i];
     1782                        for ( unsigned i = 0; i < (node->*forallField).size(); ++i ) {
     1783                                const ast::TypeDecl * type = (node->*forallField)[i];
    17841784                                if ( type->assertions.empty() ) continue;
    17851785
    … …  
    17891789                                // expand trait instances into their members
    17901790                                for ( const ast::DeclWithType * assn : type->assertions ) {
    1791                                         auto traitInst =
    1792                                                 dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
     1791                                        auto traitInst = 
     1792                                                dynamic_cast< const ast::TraitInstType * >( assn->get_type() ); 
    17931793                                        if ( traitInst ) {
    17941794                                                // expand trait instance to all its members
    … …  
    18311831} // anonymous namespace
    18321832
    1833 const ast::Type * validateType(
     1833const ast::Type * validateType( 
    18341834                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
    18351835        ast::Pass< EnumAndPointerDecay_new > epc;

  • src/SymTab/Validate.h

    rfce4e31 r302d84c2  
    1919#include <list>  // for list
    2020
    21 struct CodeLocation;
    22 class  Declaration;
    23 class  Type;
     21class CodeLocation;
     22class Declaration;
     23class Type;
    2424
    2525namespace ast {
    … …  
    3535        void validateType( Type *type, const Indexer *indexer );
    3636
    37         const ast::Type * validateType(
     37        const ast::Type * validateType( 
    3838                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab );
    3939} // namespace SymTab

  • src/SynTree/Attribute.h

    rfce4e31 r302d84c2  
    5050        Attribute * clone() const override { return new Attribute( *this ); }
    5151        virtual void accept( Visitor & v ) override { v.visit( this ); }
    52         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    5352        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    5453        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/BaseSyntaxNode.h

    rfce4e31 r302d84c2  
    3232        BaseSyntaxNode( const BaseSyntaxNode & o ) : location(o.location) { ++*new_nodes; }
    3333        BaseSyntaxNode & operator=( const BaseSyntaxNode & ) = default;
    34 
     34       
    3535        virtual ~BaseSyntaxNode() {}
    3636
    3737        virtual BaseSyntaxNode * clone() const = 0;
    3838        virtual void accept( Visitor & v ) = 0;
    39         virtual void accept( Visitor & v ) const = 0;
    4039        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
    4140        /// Notes:

  • src/SynTree/Constant.h

    rfce4e31 r302d84c2  
    3333        virtual ~Constant();
    3434
    35         virtual Constant * clone() const override { return new Constant( *this ); }
     35        virtual Constant * clone() const { return new Constant( *this ); }
    3636
    3737        Type * get_type() { return type; }
    … …  
    5151        static Constant null( Type * ptrtype = nullptr );
    5252
    53         virtual void accept( Visitor & v ) override { v.visit( this ); }
    54         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    55         virtual Constant * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    56         virtual void print( std::ostream & os, Indenter indent = 0 ) const override;
    57 
     53        virtual void accept( Visitor & v ) { v.visit( this ); }
     54        virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     55        virtual void print( std::ostream & os, Indenter indent = 0 ) const;
     56  private:
    5857        Type * type;
    5958        std::string rep;
    6059        std::optional<unsigned long long> ival;
     60
     61        friend class ConverterOldToNew;
    6162};
    6263

  • src/SynTree/Declaration.h

    rfce4e31 r302d84c2  
    6363        void fixUniqueId( void );
    6464        virtual Declaration *clone() const override = 0;
    65         virtual void accept( Visitor & v ) override = 0;
    66         virtual void accept( Visitor & v ) const override = 0;
     65        virtual void accept( Visitor &v ) override = 0;
    6766        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
    6867        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
    … …  
    140139
    141140        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
    142         virtual void accept( Visitor & v ) override { v.visit( this ); }
    143         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     141        virtual void accept( Visitor &v ) override { v.visit( this ); }
    144142        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    145143        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    171169
    172170        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
    173         virtual void accept( Visitor & v ) override { v.visit( this ); }
    174         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     171        virtual void accept( Visitor &v ) override { v.visit( this ); }
    175172        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    176173        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    241238
    242239        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
    243         virtual void accept( Visitor & v ) override { v.visit( this ); }
    244         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     240        virtual void accept( Visitor &v ) override { v.visit( this ); }
    245241        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    246242        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    260256
    261257        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
    262         virtual void accept( Visitor & v ) override { v.visit( this ); }
    263         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     258        virtual void accept( Visitor &v ) override { v.visit( this ); }
    264259        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    265260  private:
    … …  
    305300
    306301        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
    307         virtual void accept( Visitor & v ) override { v.visit( this ); }
    308         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     302        virtual void accept( Visitor &v ) override { v.visit( this ); }
    309303        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    310304        DeclarationNode::Aggregate kind;
    … …  
    320314
    321315        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
    322         virtual void accept( Visitor & v ) override { v.visit( this ); }
    323         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     316        virtual void accept( Visitor &v ) override { v.visit( this ); }
    324317        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    325318  private:
    … …  
    336329
    337330        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
    338         virtual void accept( Visitor & v ) override { v.visit( this ); }
    339         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     331        virtual void accept( Visitor &v ) override { v.visit( this ); }
    340332        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    341333  private:
    … …  
    353345
    354346        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
    355         virtual void accept( Visitor & v ) override { v.visit( this ); }
    356         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     347        virtual void accept( Visitor &v ) override { v.visit( this ); }
    357348        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    358349  private:
    … …  
    372363
    373364        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
    374         virtual void accept( Visitor & v ) override { v.visit( this ); }
    375         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     365        virtual void accept( Visitor &v ) override { v.visit( this ); }
    376366        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    377367        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    389379
    390380        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
    391         virtual void accept( Visitor & v ) override { v.visit( this ); }
    392         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     381        virtual void accept( Visitor &v ) override { v.visit( this ); }
    393382        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    394383        virtual void print( std::ostream &os, Indenter indent = {} ) const override;

  • src/SynTree/Expression.h

    rfce4e31 r302d84c2  
    8282        virtual Expression * clone() const override = 0;
    8383        virtual void accept( Visitor & v ) override = 0;
    84         virtual void accept( Visitor & v ) const override = 0;
    8584        virtual Expression * acceptMutator( Mutator & m ) override = 0;
    8685        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    102101        std::list<Expression *>& get_args() { return args; }
    103102
    104         virtual ApplicationExpr * clone() const override { return new ApplicationExpr( * this ); }
    105         virtual void accept( Visitor & v ) override { v.visit( this ); }
    106         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    107         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    108         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     103        virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
     104        virtual void accept( Visitor & v ) { v.visit( this ); }
     105        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     106        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    109107};
    110108
    … …  
    131129        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
    132130
    133         virtual UntypedExpr * clone() const override { return new UntypedExpr( * this ); }
    134         virtual void accept( Visitor & v ) override { v.visit( this ); }
    135         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    136         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    137         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     131        virtual UntypedExpr * clone() const { return new UntypedExpr( * this ); }
     132        virtual void accept( Visitor & v ) { v.visit( this ); }
     133        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     134        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    138135};
    139136
    … …  
    150147        void set_name( std::string newValue ) { name = newValue; }
    151148
    152         virtual NameExpr * clone() const override { return new NameExpr( * this ); }
    153         virtual void accept( Visitor & v ) override { v.visit( this ); }
    154         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    155         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    156         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     149        virtual NameExpr * clone() const { return new NameExpr( * this ); }
     150        virtual void accept( Visitor & v ) { v.visit( this ); }
     151        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     152        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    157153};
    158154
    … …  
    172168        void set_arg(Expression * newValue ) { arg = newValue; }
    173169
    174         virtual AddressExpr * clone() const override { return new AddressExpr( * this ); }
    175         virtual void accept( Visitor & v ) override { v.visit( this ); }
    176         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    177         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    178         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     170        virtual AddressExpr * clone() const { return new AddressExpr( * this ); }
     171        virtual void accept( Visitor & v ) { v.visit( this ); }
     172        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     173        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    179174};
    180175
    … …  
    189184        virtual ~LabelAddressExpr();
    190185
    191         virtual LabelAddressExpr * clone() const override { return new LabelAddressExpr( * this ); }
    192         virtual void accept( Visitor & v ) override { v.visit( this ); }
    193         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    194         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    195         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     186        virtual LabelAddressExpr * clone() const { return new LabelAddressExpr( * this ); }
     187        virtual void accept( Visitor & v ) { v.visit( this ); }
     188        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     189        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    196190};
    197191
    … …  
    211205        void set_arg( Expression * newValue ) { arg = newValue; }
    212206
    213         virtual CastExpr * clone() const override { return new CastExpr( * this ); }
    214         virtual void accept( Visitor & v ) override { v.visit( this ); }
    215         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    216         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    217         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     207        virtual CastExpr * clone() const { return new CastExpr( * this ); }
     208        virtual void accept( Visitor & v ) { v.visit( this ); }
     209        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     210        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    218211};
    219212
    … …  
    232225        const std::string & targetString() const;
    233226
    234         virtual KeywordCastExpr * clone() const override { return new KeywordCastExpr( * this ); }
    235         virtual void accept( Visitor & v ) override { v.visit( this ); }
    236         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    237         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    238         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     227        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
     228        virtual void accept( Visitor & v ) { v.visit( this ); }
     229        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     230        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    239231};
    240232
    … …  
    251243        void set_arg( Expression * newValue ) { arg = newValue; }
    252244
    253         virtual VirtualCastExpr * clone() const override { return new VirtualCastExpr( * this ); }
    254         virtual void accept( Visitor & v ) override { v.visit( this ); }
    255         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    256         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    257         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     245        virtual VirtualCastExpr * clone() const { return new VirtualCastExpr( * this ); }
     246        virtual void accept( Visitor & v ) { v.visit( this ); }
     247        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     248        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    258249};
    259250
    … …  
    273264        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    274265
    275         virtual UntypedMemberExpr * clone() const override { return new UntypedMemberExpr( * this ); }
    276         virtual void accept( Visitor & v ) override { v.visit( this ); }
    277         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    278         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    279         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     266        virtual UntypedMemberExpr * clone() const { return new UntypedMemberExpr( * this ); }
     267        virtual void accept( Visitor & v ) { v.visit( this ); }
     268        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     269        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    280270};
    281271
    … …  
    296286        void set_aggregate( Expression * newValue ) { aggregate = newValue; }
    297287
    298         virtual MemberExpr * clone() const override { return new MemberExpr( * this ); }
    299         virtual void accept( Visitor & v ) override { v.visit( this ); }
    300         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    301         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    302         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     288        virtual MemberExpr * clone() const { return new MemberExpr( * this ); }
     289        virtual void accept( Visitor & v ) { v.visit( this ); }
     290        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     291        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    303292};
    304293
    … …  
    319308        static VariableExpr * functionPointer( FunctionDecl * decl );
    320309
    321         virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
    322         virtual void accept( Visitor & v ) override { v.visit( this ); }
    323         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    324         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    325         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     310        virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
     311        virtual void accept( Visitor & v ) { v.visit( this ); }
     312        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     313        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    326314};
    327315
    … …  
    341329        long long int intValue() const;
    342330
    343         virtual ConstantExpr * clone() const override { return new ConstantExpr( * this ); }
    344         virtual void accept( Visitor & v ) override { v.visit( this ); }
    345         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    346         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    347         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     331        virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }
     332        virtual void accept( Visitor & v ) { v.visit( this ); }
     333        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     334        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    348335};
    349336
    … …  
    367354        void set_isType( bool newValue ) { isType = newValue; }
    368355
    369         virtual SizeofExpr * clone() const override { return new SizeofExpr( * this ); }
    370         virtual void accept( Visitor & v ) override { v.visit( this ); }
    371         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    372         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    373         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     356        virtual SizeofExpr * clone() const { return new SizeofExpr( * this ); }
     357        virtual void accept( Visitor & v ) { v.visit( this ); }
     358        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     359        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    374360};
    375361
    … …  
    393379        void set_isType( bool newValue ) { isType = newValue; }
    394380
    395         virtual AlignofExpr * clone() const override { return new AlignofExpr( * this ); }
    396         virtual void accept( Visitor & v ) override { v.visit( this ); }
    397         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    398         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    399         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     381        virtual AlignofExpr * clone() const { return new AlignofExpr( * this ); }
     382        virtual void accept( Visitor & v ) { v.visit( this ); }
     383        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     384        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    400385};
    401386
    … …  
    415400        void set_type( Type * newValue ) { type = newValue; }
    416401
    417         virtual UntypedOffsetofExpr * clone() const override { return new UntypedOffsetofExpr( * this ); }
    418         virtual void accept( Visitor & v ) override { v.visit( this ); }
    419         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    420         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    421         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     402        virtual UntypedOffsetofExpr * clone() const { return new UntypedOffsetofExpr( * this ); }
     403        virtual void accept( Visitor & v ) { v.visit( this ); }
     404        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     405        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    422406};
    423407
    … …  
    437421        void set_member( DeclarationWithType * newValue ) { member = newValue; }
    438422
    439         virtual OffsetofExpr * clone() const override { return new OffsetofExpr( * this ); }
    440         virtual void accept( Visitor & v ) override { v.visit( this ); }
    441         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    442         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    443         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     423        virtual OffsetofExpr * clone() const { return new OffsetofExpr( * this ); }
     424        virtual void accept( Visitor & v ) { v.visit( this ); }
     425        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     426        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    444427};
    445428
    … …  
    456439        void set_type( StructInstType * newValue ) { type = newValue; }
    457440
    458         virtual OffsetPackExpr * clone() const override { return new OffsetPackExpr( * this ); }
    459         virtual void accept( Visitor & v ) override { v.visit( this ); }
    460         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    461         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    462         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     441        virtual OffsetPackExpr * clone() const { return new OffsetPackExpr( * this ); }
     442        virtual void accept( Visitor & v ) { v.visit( this ); }
     443        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     444        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    463445};
    464446
    … …  
    485467        void set_isType( bool newValue ) { isType = newValue; }
    486468
    487         virtual AttrExpr * clone() const override { return new AttrExpr( * this ); }
    488         virtual void accept( Visitor & v ) override { v.visit( this ); }
    489         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    490         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    491         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     469        virtual AttrExpr * clone() const { return new AttrExpr( * this ); }
     470        virtual void accept( Visitor & v ) { v.visit( this ); }
     471        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     472        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    492473};
    493474
    … …  
    508489        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    509490
    510         virtual LogicalExpr * clone() const override { return new LogicalExpr( * this ); }
    511         virtual void accept( Visitor & v ) override { v.visit( this ); }
    512         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    513         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    514         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     491        virtual LogicalExpr * clone() const { return new LogicalExpr( * this ); }
     492        virtual void accept( Visitor & v ) { v.visit( this ); }
     493        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     494        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    515495
    516496  private:
    … …  
    536516        void set_arg3( Expression * newValue ) { arg3 = newValue; }
    537517
    538         virtual ConditionalExpr * clone() const override { return new ConditionalExpr( * this ); }
    539         virtual void accept( Visitor & v ) override { v.visit( this ); }
    540         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    541         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    542         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     518        virtual ConditionalExpr * clone() const { return new ConditionalExpr( * this ); }
     519        virtual void accept( Visitor & v ) { v.visit( this ); }
     520        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     521        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    543522};
    544523
    … …  
    558537        void set_arg2( Expression * newValue ) { arg2 = newValue; }
    559538
    560         virtual CommaExpr * clone() const override { return new CommaExpr( * this ); }
    561         virtual void accept( Visitor & v ) override { v.visit( this ); }
    562         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    563         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    564         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     539        virtual CommaExpr * clone() const { return new CommaExpr( * this ); }
     540        virtual void accept( Visitor & v ) { v.visit( this ); }
     541        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     542        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    565543};
    566544
    … …  
    577555        void set_type( Type * newValue ) { type = newValue; }
    578556
    579         virtual TypeExpr * clone() const override { return new TypeExpr( * this ); }
    580         virtual void accept( Visitor & v ) override { v.visit( this ); }
    581         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    582         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    583         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     557        virtual TypeExpr * clone() const { return new TypeExpr( * this ); }
     558        virtual void accept( Visitor & v ) { v.visit( this ); }
     559        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     560        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    584561};
    585562
    … …  
    604581        void set_operand( Expression * newValue ) { operand = newValue; }
    605582
    606         virtual AsmExpr * clone() const override { return new AsmExpr( * this ); }
    607         virtual void accept( Visitor & v ) override { v.visit( this ); }
    608         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    609         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    610         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     583        virtual AsmExpr * clone() const { return new AsmExpr( * this ); }
     584        virtual void accept( Visitor & v ) { v.visit( this ); }
     585        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     586        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    611587
    612588        // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
    … …  
    623599        virtual ~ImplicitCopyCtorExpr();
    624600
    625         virtual ImplicitCopyCtorExpr * clone() const override { return new ImplicitCopyCtorExpr( * this ); }
    626         virtual void accept( Visitor & v ) override { v.visit( this ); }
    627         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    628         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    629         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     601        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }
     602        virtual void accept( Visitor & v ) { v.visit( this ); }
     603        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     604        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    630605};
    631606
    … …  
    642617        void set_callExpr( Expression * newValue ) { callExpr = newValue; }
    643618
    644         virtual ConstructorExpr * clone() const override { return new ConstructorExpr( * this ); }
    645         virtual void accept( Visitor & v ) override { v.visit( this ); }
    646         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    647         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    648         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     619        virtual ConstructorExpr * clone() const { return new ConstructorExpr( * this ); }
     620        virtual void accept( Visitor & v ) { v.visit( this ); }
     621        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     622        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    649623};
    650624
    … …  
    661635        void set_initializer( Initializer * i ) { initializer = i; }
    662636
    663         virtual CompoundLiteralExpr * clone() const override { return new CompoundLiteralExpr( * this ); }
    664         virtual void accept( Visitor & v ) override { v.visit( this ); }
    665         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    666         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    667         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     637        virtual CompoundLiteralExpr * clone() const { return new CompoundLiteralExpr( * this ); }
     638        virtual void accept( Visitor & v ) { v.visit( this ); }
     639        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     640        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    668641};
    669642
    … …  
    681654        RangeExpr * set_high( Expression * high ) { RangeExpr::high = high; return this; }
    682655
    683         virtual RangeExpr * clone() const override { return new RangeExpr( * this ); }
    684         virtual void accept( Visitor & v ) override { v.visit( this ); }
    685         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    686         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    687         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     656        virtual RangeExpr * clone() const { return new RangeExpr( * this ); }
     657        virtual void accept( Visitor & v ) { v.visit( this ); }
     658        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     659        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    688660};
    689661
    … …  
    699671        std::list<Expression*>& get_exprs() { return exprs; }
    700672
    701         virtual UntypedTupleExpr * clone() const override { return new UntypedTupleExpr( * this ); }
    702         virtual void accept( Visitor & v ) override { v.visit( this ); }
    703         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    704         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    705         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     673        virtual UntypedTupleExpr * clone() const { return new UntypedTupleExpr( * this ); }
     674        virtual void accept( Visitor & v ) { v.visit( this ); }
     675        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     676        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    706677};
    707678
    … …  
    717688        std::list<Expression*>& get_exprs() { return exprs; }
    718689
    719         virtual TupleExpr * clone() const override { return new TupleExpr( * this ); }
    720         virtual void accept( Visitor & v ) override { v.visit( this ); }
    721         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    722         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    723         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     690        virtual TupleExpr * clone() const { return new TupleExpr( * this ); }
     691        virtual void accept( Visitor & v ) { v.visit( this ); }
     692        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     693        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    724694};
    725695
    … …  
    739709        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
    740710
    741         virtual TupleIndexExpr * clone() const override { return new TupleIndexExpr( * this ); }
    742         virtual void accept( Visitor & v ) override { v.visit( this ); }
    743         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    744         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    745         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     711        virtual TupleIndexExpr * clone() const { return new TupleIndexExpr( * this ); }
     712        virtual void accept( Visitor & v ) { v.visit( this ); }
     713        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     714        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    746715};
    747716
    … …  
    758727        StmtExpr * get_stmtExpr() const { return stmtExpr; }
    759728
    760         virtual TupleAssignExpr * clone() const override { return new TupleAssignExpr( * this ); }
    761         virtual void accept( Visitor & v ) override { v.visit( this ); }
    762         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    763         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    764         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     729        virtual TupleAssignExpr * clone() const { return new TupleAssignExpr( * this ); }
     730        virtual void accept( Visitor & v ) { v.visit( this ); }
     731        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     732        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    765733
    766734        friend class ConverterNewToOld;
    … …  
    792760        std::list< Expression * > & get_dtors() { return dtors; }
    793761
    794         virtual StmtExpr * clone() const override { return new StmtExpr( * this ); }
    795         virtual void accept( Visitor & v ) override { v.visit( this ); }
    796         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    797         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    798         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     762        virtual StmtExpr * clone() const { return new StmtExpr( * this ); }
     763        virtual void accept( Visitor & v ) { v.visit( this ); }
     764        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     765        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    799766};
    800767
    … …  
    820787        int get_id() const { return id; }
    821788
    822         virtual UniqueExpr * clone() const override { return new UniqueExpr( * this ); }
    823         virtual void accept( Visitor & v ) override { v.visit( this ); }
    824         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    825         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    826         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     789        virtual UniqueExpr * clone() const { return new UniqueExpr( * this ); }
     790        virtual void accept( Visitor & v ) { v.visit( this ); }
     791        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     792        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    827793
    828794private:
    … …  
    855821        std::list<InitAlternative> & get_initAlts() { return initAlts; }
    856822
    857         virtual UntypedInitExpr * clone() const override { return new UntypedInitExpr( * this ); }
    858         virtual void accept( Visitor & v ) override { v.visit( this ); }
    859         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    860         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    861         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     823        virtual UntypedInitExpr * clone() const { return new UntypedInitExpr( * this ); }
     824        virtual void accept( Visitor & v ) { v.visit( this ); }
     825        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     826        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    862827};
    863828
    … …  
    877842        InitExpr * set_designation( Designation * newValue ) { designation = newValue; return this; }
    878843
    879         virtual InitExpr * clone() const override { return new InitExpr( * this ); }
    880         virtual void accept( Visitor & v ) override { v.visit( this ); }
    881         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    882         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    883         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     844        virtual InitExpr * clone() const { return new InitExpr( * this ); }
     845        virtual void accept( Visitor & v ) { v.visit( this ); }
     846        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     847        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    884848};
    885849
    … …  
    894858        ~DeletedExpr();
    895859
    896         virtual DeletedExpr * clone() const override { return new DeletedExpr( * this ); }
    897         virtual void accept( Visitor & v ) override { v.visit( this ); }
    898         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    899         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    900         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     860        virtual DeletedExpr * clone() const { return new DeletedExpr( * this ); }
     861        virtual void accept( Visitor & v ) { v.visit( this ); }
     862        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     863        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    901864};
    902865
    … …  
    910873        ~DefaultArgExpr();
    911874
    912         virtual DefaultArgExpr * clone() const override { return new DefaultArgExpr( * this ); }
    913         virtual void accept( Visitor & v ) override { v.visit( this ); }
    914         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    915         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    916         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     875        virtual DefaultArgExpr * clone() const { return new DefaultArgExpr( * this ); }
     876        virtual void accept( Visitor & v ) { v.visit( this ); }
     877        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     878        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    917879};
    918880
    … …  
    939901        virtual ~GenericExpr();
    940902
    941         virtual GenericExpr * clone() const override { return new GenericExpr( * this ); }
    942         virtual void accept( Visitor & v ) override { v.visit( this ); }
    943         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    944         virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    945         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     903        virtual GenericExpr * clone() const { return new GenericExpr( * this ); }
     904        virtual void accept( Visitor & v ) { v.visit( this ); }
     905        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     906        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    946907};
    947908

  • src/SynTree/Initializer.h

    rfce4e31 r302d84c2  
    3838
    3939        virtual Designation * clone() const override { return new Designation( *this ); };
    40         virtual void accept( Visitor & v ) override { v.visit( this ); }
    41         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     40        virtual void accept( Visitor &v ) override { v.visit( this ); }
    4241        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
    4342        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    5352        virtual ~Initializer();
    5453
    55         bool get_maybeConstructed() const { return maybeConstructed; }
     54        bool get_maybeConstructed() { return maybeConstructed; }
    5655
    5756        virtual Initializer *clone() const override = 0;
    58         virtual void accept( Visitor & v ) override = 0;
    59         virtual void accept( Visitor & v ) const override = 0;
     57        virtual void accept( Visitor &v ) override = 0;
    6058        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
    6159        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
    … …  
    7876
    7977        virtual SingleInit *clone() const override { return new SingleInit( *this); }
    80         virtual void accept( Visitor & v ) override { v.visit( this ); }
    81         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     78        virtual void accept( Visitor &v ) override { v.visit( this ); }
    8279        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    8380        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    107104
    108105        virtual ListInit *clone() const override { return new ListInit( *this ); }
    109         virtual void accept( Visitor & v ) override { v.visit( this ); }
    110         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     106        virtual void accept( Visitor &v ) override { v.visit( this ); }
    111107        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    112108        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
    … …  
    137133
    138134        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
    139         virtual void accept( Visitor & v ) override { v.visit( this ); }
    140         virtual void accept( Visitor & v ) const override { v.visit( this ); }
     135        virtual void accept( Visitor &v ) override { v.visit( this ); }
    141136        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    142137        virtual void print( std::ostream &os, Indenter indent = {} ) const override;

  • src/SynTree/Statement.h

    rfce4e31 r302d84c2  
    4545        virtual Statement * clone() const override = 0;
    4646        virtual void accept( Visitor & v ) override = 0;
    47         virtual void accept( Visitor & v ) const override = 0;
    4847        virtual Statement * acceptMutator( Mutator & m ) override = 0;
    4948        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    6564        virtual CompoundStmt * clone() const override { return new CompoundStmt( *this ); }
    6665        virtual void accept( Visitor & v ) override { v.visit( this ); }
    67         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    6866        virtual CompoundStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    6967        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    7674        virtual NullStmt * clone() const override { return new NullStmt( *this ); }
    7775        virtual void accept( Visitor & v ) override { v.visit( this ); }
    78         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    7976        virtual NullStmt * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    8077        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    9491        virtual ExprStmt * clone() const override { return new ExprStmt( *this ); }
    9592        virtual void accept( Visitor & v ) override { v.visit( this ); }
    96         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    9793        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    9894        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    124120        void set_gotolabels( const std::list<Label> & newValue ) { gotolabels = newValue; }
    125121
    126         virtual AsmStmt * clone() const override { return new AsmStmt( *this ); }
    127         virtual void accept( Visitor & v ) override { v.visit( this ); }
    128         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    129         virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    130         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     122        virtual AsmStmt * clone() const { return new AsmStmt( *this ); }
     123        virtual void accept( Visitor & v ) { v.visit( this ); }
     124        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     125        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    131126};
    132127
    … …  
    138133        virtual ~DirectiveStmt(){}
    139134
    140         virtual DirectiveStmt * clone() const override { return new DirectiveStmt( *this ); }
    141         virtual void accept( Visitor & v ) override { v.visit( this ); }
    142         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    143         virtual Statement * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    144         virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     135        virtual DirectiveStmt * clone() const { return new DirectiveStmt( *this ); }
     136        virtual void accept( Visitor & v ) { v.visit( this ); }
     137        virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     138        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    145139};
    146140
    … …  
    167161        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
    168162        virtual void accept( Visitor & v ) override { v.visit( this ); }
    169         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    170163        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    171164        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    187180
    188181        virtual void accept( Visitor & v ) override { v.visit( this ); }
    189         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    190182        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    191183
    … …  
    216208
    217209        virtual void accept( Visitor & v ) override { v.visit( this ); }
    218         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    219210        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    220211
    … …  
    245236        virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
    246237        virtual void accept( Visitor & v ) override { v.visit( this ); }
    247         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    248238        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    249239        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    271261        virtual ForStmt * clone() const override { return new ForStmt( *this ); }
    272262        virtual void accept( Visitor & v ) override { v.visit( this ); }
    273         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    274263        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    275264        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    301290        virtual BranchStmt * clone() const override { return new BranchStmt( *this ); }
    302291        virtual void accept( Visitor & v ) override { v.visit( this ); }
    303         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    304292        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    305293        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    321309        virtual ReturnStmt * clone() const override { return new ReturnStmt( *this ); }
    322310        virtual void accept( Visitor & v ) override { v.visit( this ); }
    323         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    324311        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    325312        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    346333        virtual ThrowStmt * clone() const override { return new ThrowStmt( *this ); }
    347334        virtual void accept( Visitor & v ) override { v.visit( this ); }
    348         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    349335        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    350336        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    370356        virtual TryStmt * clone() const override { return new TryStmt( *this ); }
    371357        virtual void accept( Visitor & v ) override { v.visit( this ); }
    372         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    373358        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    374359        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    399384        virtual CatchStmt * clone() const override { return new CatchStmt( *this ); }
    400385        virtual void accept( Visitor & v ) override { v.visit( this ); }
    401         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    402386        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    403387        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    417401        virtual FinallyStmt * clone() const override { return new FinallyStmt( *this ); }
    418402        virtual void accept( Visitor & v ) override { v.visit( this ); }
    419         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    420403        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    421404        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    455438        virtual WaitForStmt * clone() const override { return new WaitForStmt( *this ); }
    456439        virtual void accept( Visitor & v ) override { v.visit( this ); }
    457         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    458440        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    459441        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    472454        virtual WithStmt * clone() const override { return new WithStmt( *this ); }
    473455        virtual void accept( Visitor & v ) override { v.visit( this ); }
    474         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    475456        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    476457        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    492473        virtual DeclStmt * clone() const override { return new DeclStmt( *this ); }
    493474        virtual void accept( Visitor & v ) override { v.visit( this ); }
    494         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    495475        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    496476        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    514494        virtual ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt( *this ); }
    515495        virtual void accept( Visitor & v ) override { v.visit( this ); }
    516         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    517496        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
    518497        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/Type.h

    rfce4e31 r302d84c2  
    144144
    145145        Qualifiers & get_qualifiers() { return tq; }
    146         bool get_const() const { return tq.is_const; }
    147         bool get_volatile() const { return tq.is_volatile; }
    148         bool get_restrict() const { return tq.is_restrict; }
    149         bool get_lvalue() const { return tq.is_lvalue; }
    150         bool get_mutex() const { return tq.is_mutex; }
    151         bool get_atomic() const { return tq.is_atomic; }
     146        bool get_const() { return tq.is_const; }
     147        bool get_volatile() { return tq.is_volatile; }
     148        bool get_restrict() { return tq.is_restrict; }
     149        bool get_lvalue() { return tq.is_lvalue; }
     150        bool get_mutex() { return tq.is_mutex; }
     151        bool get_atomic() { return tq.is_atomic; }
    152152        void set_const( bool newValue ) { tq.is_const = newValue; }
    153153        void set_volatile( bool newValue ) { tq.is_volatile = newValue; }
    … …  
    184184        virtual Type *clone() const = 0;
    185185        virtual void accept( Visitor & v ) = 0;
    186         virtual void accept( Visitor & v ) const = 0;
    187186        virtual Type *acceptMutator( Mutator & m ) = 0;
    188187        virtual void print( std::ostream & os, Indenter indent = {} ) const;
    … …  
    202201        virtual VoidType *clone() const override { return new VoidType( *this ); }
    203202        virtual void accept( Visitor & v ) override { v.visit( this ); }
    204         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    205203        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    206204        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    261259        virtual BasicType *clone() const override { return new BasicType( *this ); }
    262260        virtual void accept( Visitor & v ) override { v.visit( this ); }
    263         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    264261        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    265262        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    297294        virtual PointerType *clone() const override { return new PointerType( *this ); }
    298295        virtual void accept( Visitor & v ) override { v.visit( this ); }
    299         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    300296        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    301297        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    329325        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
    330326        virtual void accept( Visitor & v ) override { v.visit( this ); }
    331         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    332327        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    333328        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    345340        virtual QualifiedType *clone() const override { return new QualifiedType( *this ); }
    346341        virtual void accept( Visitor & v ) override { v.visit( this ); }
    347         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    348342        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    349343        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    372366        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
    373367        virtual void accept( Visitor & v ) override { v.visit( this ); }
    374         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    375368        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    376369        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    402395        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
    403396        virtual void accept( Visitor & v ) override { v.visit( this ); }
    404         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    405397        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    406398        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    463455        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
    464456        virtual void accept( Visitor & v ) override { v.visit( this ); }
    465         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    466457        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    467458
    … …  
    501492        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
    502493        virtual void accept( Visitor & v ) override { v.visit( this ); }
    503         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    504494        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    505495
    … …  
    529519        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
    530520        virtual void accept( Visitor & v ) override { v.visit( this ); }
    531         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    532521        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    533522
    … …  
    553542        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
    554543        virtual void accept( Visitor & v ) override { v.visit( this ); }
    555         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    556544        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    557545  private:
    … …  
    581569        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
    582570        virtual void accept( Visitor & v ) override { v.visit( this ); }
    583         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    584571        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    585572        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    619606        virtual TupleType *clone() const override { return new TupleType( *this ); }
    620607        virtual void accept( Visitor & v ) override { v.visit( this ); }
    621         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    622608        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    623609        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    630616
    631617        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    632         TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof,
     618        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
    633619                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    634620        TypeofType( const TypeofType& );
    … …  
    642628        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
    643629        virtual void accept( Visitor & v ) override { v.visit( this ); }
    644         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    645630        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    646631        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    672657        virtual AttrType *clone() const override { return new AttrType( *this ); }
    673658        virtual void accept( Visitor & v ) override { v.visit( this ); }
    674         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    675659        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    676660        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    687671        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
    688672        virtual void accept( Visitor & v ) override { v.visit( this ); }
    689         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    690673        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    691674        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    700683        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
    701684        virtual void accept( Visitor & v ) override { v.visit( this ); }
    702         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    703685        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    704686        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    713695        virtual OneType *clone() const override { return new OneType( *this ); }
    714696        virtual void accept( Visitor & v ) override { v.visit( this ); }
    715         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    716697        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    717698        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
    … …  
    724705        virtual GlobalScopeType *clone() const override { return new GlobalScopeType( *this ); }
    725706        virtual void accept( Visitor & v ) override { v.visit( this ); }
    726         virtual void accept( Visitor & v ) const override { v.visit( this ); }
    727707        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
    728708        virtual void print( std::ostream & os, Indenter indent = {} ) const override;

  • src/SynTree/Visitor.h

    rfce4e31 r302d84c2  
    2727        // of the given syntax node, but performs no other action.
    2828
    29         virtual void visit( ObjectDecl * node ) { visit( const_cast<const ObjectDecl *>(node) ); }
    30         virtual void visit( const ObjectDecl * objectDecl ) = 0;
    31         virtual void visit( FunctionDecl * node ) { visit( const_cast<const FunctionDecl *>(node) ); }
    32         virtual void visit( const FunctionDecl * functionDecl ) = 0;
    33         virtual void visit( StructDecl * node ) { visit( const_cast<const StructDecl *>(node) ); }
    34         virtual void visit( const StructDecl * aggregateDecl ) = 0;
    35         virtual void visit( UnionDecl * node ) { visit( const_cast<const UnionDecl *>(node) ); }
    36         virtual void visit( const UnionDecl * aggregateDecl ) = 0;
    37         virtual void visit( EnumDecl * node ) { visit( const_cast<const EnumDecl *>(node) ); }
    38         virtual void visit( const EnumDecl * aggregateDecl ) = 0;
    39         virtual void visit( TraitDecl * node ) { visit( const_cast<const TraitDecl *>(node) ); }
    40         virtual void visit( const TraitDecl * aggregateDecl ) = 0;
    41         virtual void visit( TypeDecl * node ) { visit( const_cast<const TypeDecl *>(node) ); }
    42         virtual void visit( const TypeDecl * typeDecl ) = 0;
    43         virtual void visit( TypedefDecl * node ) { visit( const_cast<const TypedefDecl *>(node) ); }
    44         virtual void visit( const TypedefDecl * typeDecl ) = 0;
    45         virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
    46         virtual void visit( const AsmDecl * asmDecl ) = 0;
    47         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
    48         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
     29        virtual void visit( ObjectDecl * objectDecl ) = 0;
     30        virtual void visit( FunctionDecl * functionDecl ) = 0;
     31        virtual void visit( StructDecl * aggregateDecl ) = 0;
     32        virtual void visit( UnionDecl * aggregateDecl ) = 0;
     33        virtual void visit( EnumDecl * aggregateDecl ) = 0;
     34        virtual void visit( TraitDecl * aggregateDecl ) = 0;
     35        virtual void visit( TypeDecl * typeDecl ) = 0;
     36        virtual void visit( TypedefDecl * typeDecl ) = 0;
     37        virtual void visit( AsmDecl * asmDecl ) = 0;
     38        virtual void visit( StaticAssertDecl * assertDecl ) = 0;
    4939
    50         virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }
    51         virtual void visit( const CompoundStmt * compoundStmt ) = 0;
    52         virtual void visit( ExprStmt * node ) { visit( const_cast<const ExprStmt *>(node) ); }
    53         virtual void visit( const ExprStmt * exprStmt ) = 0;
    54         virtual void visit( AsmStmt * node ) { visit( const_cast<const AsmStmt *>(node) ); }
    55         virtual void visit( const AsmStmt * asmStmt ) = 0;
    56         virtual void visit( DirectiveStmt * node ) { visit( const_cast<const DirectiveStmt *>(node) ); }
    57         virtual void visit( const DirectiveStmt * directiveStmt ) = 0;
    58         virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
    59         virtual void visit( const IfStmt * ifStmt ) = 0;
    60         virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
    61         virtual void visit( const WhileStmt * whileStmt ) = 0;
    62         virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
    63         virtual void visit( const ForStmt * forStmt ) = 0;
    64         virtual void visit( SwitchStmt * node ) { visit( const_cast<const SwitchStmt *>(node) ); }
    65         virtual void visit( const SwitchStmt * switchStmt ) = 0;
    66         virtual void visit( CaseStmt * node ) { visit( const_cast<const CaseStmt *>(node) ); }
    67         virtual void visit( const CaseStmt * caseStmt ) = 0;
    68         virtual void visit( BranchStmt * node ) { visit( const_cast<const BranchStmt *>(node) ); }
    69         virtual void visit( const BranchStmt * branchStmt ) = 0;
    70         virtual void visit( ReturnStmt * node ) { visit( const_cast<const ReturnStmt *>(node) ); }
    71         virtual void visit( const ReturnStmt * returnStmt ) = 0;
    72         virtual void visit( ThrowStmt * node ) { visit( const_cast<const ThrowStmt *>(node) ); }
    73         virtual void visit( const ThrowStmt * throwStmt ) = 0;
    74         virtual void visit( TryStmt * node ) { visit( const_cast<const TryStmt *>(node) ); }
    75         virtual void visit( const TryStmt * tryStmt ) = 0;
    76         virtual void visit( CatchStmt * node ) { visit( const_cast<const CatchStmt *>(node) ); }
    77         virtual void visit( const CatchStmt * catchStmt ) = 0;
    78         virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
    79         virtual void visit( const FinallyStmt * finallyStmt ) = 0;
    80         virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
    81         virtual void visit( const WaitForStmt * waitforStmt ) = 0;
    82         virtual void visit( WithStmt * node ) { visit( const_cast<const WithStmt *>(node) ); }
    83         virtual void visit( const WithStmt * withStmt ) = 0;
    84         virtual void visit( NullStmt * node ) { visit( const_cast<const NullStmt *>(node) ); }
    85         virtual void visit( const NullStmt * nullStmt ) = 0;
    86         virtual void visit( DeclStmt * node ) { visit( const_cast<const DeclStmt *>(node) ); }
    87         virtual void visit( const DeclStmt * declStmt ) = 0;
    88         virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
    89         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     40        virtual void visit( CompoundStmt * compoundStmt ) = 0;
     41        virtual void visit( ExprStmt * exprStmt ) = 0;
     42        virtual void visit( AsmStmt * asmStmt ) = 0;
     43        virtual void visit( DirectiveStmt * directiveStmt ) = 0;
     44        virtual void visit( IfStmt * ifStmt ) = 0;
     45        virtual void visit( WhileStmt * whileStmt ) = 0;
     46        virtual void visit( ForStmt * forStmt ) = 0;
     47        virtual void visit( SwitchStmt * switchStmt ) = 0;
     48        virtual void visit( CaseStmt * caseStmt ) = 0;
     49        virtual void visit( BranchStmt * branchStmt ) = 0;
     50        virtual void visit( ReturnStmt * returnStmt ) = 0;
     51        virtual void visit( ThrowStmt * throwStmt ) = 0;
     52        virtual void visit( TryStmt * tryStmt ) = 0;
     53        virtual void visit( CatchStmt * catchStmt ) = 0;
     54        virtual void visit( FinallyStmt * finallyStmt ) = 0;
     55        virtual void visit( WaitForStmt * waitforStmt ) = 0;
     56        virtual void visit( WithStmt * withStmt ) = 0;
     57        virtual void visit( NullStmt * nullStmt ) = 0;
     58        virtual void visit( DeclStmt * declStmt ) = 0;
     59        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
    9060
    91         virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
    92         virtual void visit( const ApplicationExpr * applicationExpr ) = 0;
    93         virtual void visit( UntypedExpr * node ) { visit( const_cast<const UntypedExpr *>(node) ); }
    94         virtual void visit( const UntypedExpr * untypedExpr ) = 0;
    95         virtual void visit( NameExpr * node ) { visit( const_cast<const NameExpr *>(node) ); }
    96         virtual void visit( const NameExpr * nameExpr ) = 0;
    97         virtual void visit( CastExpr * node ) { visit( const_cast<const CastExpr *>(node) ); }
    98         virtual void visit( const CastExpr * castExpr ) = 0;
    99         virtual void visit( KeywordCastExpr * node ) { visit( const_cast<const KeywordCastExpr *>(node) ); }
    100         virtual void visit( const KeywordCastExpr * castExpr ) = 0;
    101         virtual void visit( VirtualCastExpr * node ) { visit( const_cast<const VirtualCastExpr *>(node) ); }
    102         virtual void visit( const VirtualCastExpr * castExpr ) = 0;
    103         virtual void visit( AddressExpr * node ) { visit( const_cast<const AddressExpr *>(node) ); }
    104         virtual void visit( const AddressExpr * addressExpr ) = 0;
    105         virtual void visit( LabelAddressExpr * node ) { visit( const_cast<const LabelAddressExpr *>(node) ); }
    106         virtual void visit( const LabelAddressExpr * labAddressExpr ) = 0;
    107         virtual void visit( UntypedMemberExpr * node ) { visit( const_cast<const UntypedMemberExpr *>(node) ); }
    108         virtual void visit( const UntypedMemberExpr * memberExpr ) = 0;
    109         virtual void visit( MemberExpr * node ) { visit( const_cast<const MemberExpr *>(node) ); }
    110         virtual void visit( const MemberExpr * memberExpr ) = 0;
    111         virtual void visit( VariableExpr * node ) { visit( const_cast<const VariableExpr *>(node) ); }
    112         virtual void visit( const VariableExpr * variableExpr ) = 0;
    113         virtual void visit( ConstantExpr * node ) { visit( const_cast<const ConstantExpr *>(node) ); }
    114         virtual void visit( const ConstantExpr * constantExpr ) = 0;
    115         virtual void visit( SizeofExpr * node ) { visit( const_cast<const SizeofExpr *>(node) ); }
    116         virtual void visit( const SizeofExpr * sizeofExpr ) = 0;
    117         virtual void visit( AlignofExpr * node ) { visit( const_cast<const AlignofExpr *>(node) ); }
    118         virtual void visit( const AlignofExpr * alignofExpr ) = 0;
    119         virtual void visit( UntypedOffsetofExpr * node ) { visit( const_cast<const UntypedOffsetofExpr *>(node) ); }
    120         virtual void visit( const UntypedOffsetofExpr * offsetofExpr ) = 0;
    121         virtual void visit( OffsetofExpr * node ) { visit( const_cast<const OffsetofExpr *>(node) ); }
    122         virtual void visit( const OffsetofExpr * offsetofExpr ) = 0;
    123         virtual void visit( OffsetPackExpr * node ) { visit( const_cast<const OffsetPackExpr *>(node) ); }
    124         virtual void visit( const OffsetPackExpr * offsetPackExpr ) = 0;
    125         virtual void visit( AttrExpr * node ) { visit( const_cast<const AttrExpr *>(node) ); }
    126         virtual void visit( const AttrExpr * attrExpr ) = 0;
    127         virtual void visit( LogicalExpr * node ) { visit( const_cast<const LogicalExpr *>(node) ); }
    128         virtual void visit( const LogicalExpr * logicalExpr ) = 0;
    129         virtual void visit( ConditionalExpr * node ) { visit( const_cast<const ConditionalExpr *>(node) ); }
    130         virtual void visit( const ConditionalExpr * conditionalExpr ) = 0;
    131         virtual void visit( CommaExpr * node ) { visit( const_cast<const CommaExpr *>(node) ); }
    132         virtual void visit( const CommaExpr * commaExpr ) = 0;
    133         virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
    134         virtual void visit( const TypeExpr * typeExpr ) = 0;
    135         virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
    136         virtual void visit( const AsmExpr * asmExpr ) = 0;
    137         virtual void visit( ImplicitCopyCtorExpr * node ) { visit( const_cast<const ImplicitCopyCtorExpr *>(node) ); }
    138         virtual void visit( const ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
    139         virtual void visit( ConstructorExpr * node ) { visit( const_cast<const ConstructorExpr *>(node) ); }
    140         virtual void visit( const ConstructorExpr *  ctorExpr ) = 0;
    141         virtual void visit( CompoundLiteralExpr * node ) { visit( const_cast<const CompoundLiteralExpr *>(node) ); }
    142         virtual void visit( const CompoundLiteralExpr * compLitExpr ) = 0;
    143         virtual void visit( RangeExpr * node ) { visit( const_cast<const RangeExpr *>(node) ); }
    144         virtual void visit( const RangeExpr * rangeExpr ) = 0;
    145         virtual void visit( UntypedTupleExpr * node ) { visit( const_cast<const UntypedTupleExpr *>(node) ); }
    146         virtual void visit( const UntypedTupleExpr * tupleExpr ) = 0;
    147         virtual void visit( TupleExpr * node ) { visit( const_cast<const TupleExpr *>(node) ); }
    148         virtual void visit( const TupleExpr * tupleExpr ) = 0;
    149         virtual void visit( TupleIndexExpr * node ) { visit( const_cast<const TupleIndexExpr *>(node) ); }
    150         virtual void visit( const TupleIndexExpr * tupleExpr ) = 0;
    151         virtual void visit( TupleAssignExpr * node ) { visit( const_cast<const TupleAssignExpr *>(node) ); }
    152         virtual void visit( const TupleAssignExpr * assignExpr ) = 0;
    153         virtual void visit( StmtExpr * node ) { visit( const_cast<const StmtExpr *>(node) ); }
    154         virtual void visit( const StmtExpr *  stmtExpr ) = 0;
    155         virtual void visit( UniqueExpr * node ) { visit( const_cast<const UniqueExpr *>(node) ); }
    156         virtual void visit( const UniqueExpr *  uniqueExpr ) = 0;
    157         virtual void visit( UntypedInitExpr * node ) { visit( const_cast<const UntypedInitExpr *>(node) ); }
    158         virtual void visit( const UntypedInitExpr *  initExpr ) = 0;
    159         virtual void visit( InitExpr * node ) { visit( const_cast<const InitExpr *>(node) ); }
    160         virtual void visit( const InitExpr *  initExpr ) = 0;
    161         virtual void visit( DeletedExpr * node ) { visit( const_cast<const DeletedExpr *>(node) ); }
    162         virtual void visit( const DeletedExpr * delExpr ) = 0;
    163         virtual void visit( DefaultArgExpr * node ) { visit( const_cast<const DefaultArgExpr *>(node) ); }
    164         virtual void visit( const DefaultArgExpr * argExpr ) = 0;
    165         virtual void visit( GenericExpr * node ) { visit( const_cast<const GenericExpr *>(node) ); }
    166         virtual void visit( const GenericExpr * genExpr ) = 0;
     61        virtual void visit( ApplicationExpr * applicationExpr ) = 0;
     62        virtual void visit( UntypedExpr * untypedExpr ) = 0;
     63        virtual void visit( NameExpr * nameExpr ) = 0;
     64        virtual void visit( CastExpr * castExpr ) = 0;
     65        virtual void visit( KeywordCastExpr * castExpr ) = 0;
     66        virtual void visit( VirtualCastExpr * castExpr ) = 0;
     67        virtual void visit( AddressExpr * addressExpr ) = 0;
     68        virtual void visit( LabelAddressExpr * labAddressExpr ) = 0;
     69        virtual void visit( UntypedMemberExpr * memberExpr ) = 0;
     70        virtual void visit( MemberExpr * memberExpr ) = 0;
     71        virtual void visit( VariableExpr * variableExpr ) = 0;
     72        virtual void visit( ConstantExpr * constantExpr ) = 0;
     73        virtual void visit( SizeofExpr * sizeofExpr ) = 0;
     74        virtual void visit( AlignofExpr * alignofExpr ) = 0;
     75        virtual void visit( UntypedOffsetofExpr * offsetofExpr ) = 0;
     76        virtual void visit( OffsetofExpr * offsetofExpr ) = 0;
     77        virtual void visit( OffsetPackExpr * offsetPackExpr ) = 0;
     78        virtual void visit( AttrExpr * attrExpr ) = 0;
     79        virtual void visit( LogicalExpr * logicalExpr ) = 0;
     80        virtual void visit( ConditionalExpr * conditionalExpr ) = 0;
     81        virtual void visit( CommaExpr * commaExpr ) = 0;
     82        virtual void visit( TypeExpr * typeExpr ) = 0;
     83        virtual void visit( AsmExpr * asmExpr ) = 0;
     84        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;
     85        virtual void visit( ConstructorExpr *  ctorExpr ) = 0;
     86        virtual void visit( CompoundLiteralExpr * compLitExpr ) = 0;
     87        virtual void visit( RangeExpr * rangeExpr ) = 0;
     88        virtual void visit( UntypedTupleExpr * tupleExpr ) = 0;
     89        virtual void visit( TupleExpr * tupleExpr ) = 0;
     90        virtual void visit( TupleIndexExpr * tupleExpr ) = 0;
     91        virtual void visit( TupleAssignExpr * assignExpr ) = 0;
     92        virtual void visit( StmtExpr *  stmtExpr ) = 0;
     93        virtual void visit( UniqueExpr *  uniqueExpr ) = 0;
     94        virtual void visit( UntypedInitExpr *  initExpr ) = 0;
     95        virtual void visit( InitExpr *  initExpr ) = 0;
     96        virtual void visit( DeletedExpr * delExpr ) = 0;
     97        virtual void visit( DefaultArgExpr * argExpr ) = 0;
     98        virtual void visit( GenericExpr * genExpr ) = 0;
    16799
    168         virtual void visit( VoidType * node ) { visit( const_cast<const VoidType *>(node) ); }
    169         virtual void visit( const VoidType * basicType ) = 0;
    170         virtual void visit( BasicType * node ) { visit( const_cast<const BasicType *>(node) ); }
    171         virtual void visit( const BasicType * basicType ) = 0;
    172         virtual void visit( PointerType * node ) { visit( const_cast<const PointerType *>(node) ); }
    173         virtual void visit( const PointerType * pointerType ) = 0;
    174         virtual void visit( ArrayType * node ) { visit( const_cast<const ArrayType *>(node) ); }
    175         virtual void visit( const ArrayType * arrayType ) = 0;
    176         virtual void visit( ReferenceType * node ) { visit( const_cast<const ReferenceType *>(node) ); }
    177         virtual void visit( const ReferenceType * refType ) = 0;
    178         virtual void visit( QualifiedType * node ) { visit( const_cast<const QualifiedType *>(node) ); }
    179         virtual void visit( const QualifiedType * qualType ) = 0;
    180         virtual void visit( FunctionType * node ) { visit( const_cast<const FunctionType *>(node) ); }
    181         virtual void visit( const FunctionType * functionType ) = 0;
    182         virtual void visit( StructInstType * node ) { visit( const_cast<const StructInstType *>(node) ); }
    183         virtual void visit( const StructInstType * aggregateUseType ) = 0;
    184         virtual void visit( UnionInstType * node ) { visit( const_cast<const UnionInstType *>(node) ); }
    185         virtual void visit( const UnionInstType * aggregateUseType ) = 0;
    186         virtual void visit( EnumInstType * node ) { visit( const_cast<const EnumInstType *>(node) ); }
    187         virtual void visit( const EnumInstType * aggregateUseType ) = 0;
    188         virtual void visit( TraitInstType * node ) { visit( const_cast<const TraitInstType *>(node) ); }
    189         virtual void visit( const TraitInstType * aggregateUseType ) = 0;
    190         virtual void visit( TypeInstType * node ) { visit( const_cast<const TypeInstType *>(node) ); }
    191         virtual void visit( const TypeInstType * aggregateUseType ) = 0;
    192         virtual void visit( TupleType * node ) { visit( const_cast<const TupleType *>(node) ); }
    193         virtual void visit( const TupleType * tupleType ) = 0;
    194         virtual void visit( TypeofType * node ) { visit( const_cast<const TypeofType *>(node) ); }
    195         virtual void visit( const TypeofType * typeofType ) = 0;
    196         virtual void visit( AttrType * node ) { visit( const_cast<const AttrType *>(node) ); }
    197         virtual void visit( const AttrType * attrType ) = 0;
    198         virtual void visit( VarArgsType * node ) { visit( const_cast<const VarArgsType *>(node) ); }
    199         virtual void visit( const VarArgsType * varArgsType ) = 0;
    200         virtual void visit( ZeroType * node ) { visit( const_cast<const ZeroType *>(node) ); }
    201         virtual void visit( const ZeroType * zeroType ) = 0;
    202         virtual void visit( OneType * node ) { visit( const_cast<const OneType *>(node) ); }
    203         virtual void visit( const OneType * oneType ) = 0;
    204         virtual void visit( GlobalScopeType * node ) { visit( const_cast<const GlobalScopeType *>(node) ); }
    205         virtual void visit( const GlobalScopeType * globalType ) = 0;
     100        virtual void visit( VoidType * basicType ) = 0;
     101        virtual void visit( BasicType * basicType ) = 0;
     102        virtual void visit( PointerType * pointerType ) = 0;
     103        virtual void visit( ArrayType * arrayType ) = 0;
     104        virtual void visit( ReferenceType * refType ) = 0;
     105        virtual void visit( QualifiedType * qualType ) = 0;
     106        virtual void visit( FunctionType * functionType ) = 0;
     107        virtual void visit( StructInstType * aggregateUseType ) = 0;
     108        virtual void visit( UnionInstType * aggregateUseType ) = 0;
     109        virtual void visit( EnumInstType * aggregateUseType ) = 0;
     110        virtual void visit( TraitInstType * aggregateUseType ) = 0;
     111        virtual void visit( TypeInstType * aggregateUseType ) = 0;
     112        virtual void visit( TupleType * tupleType ) = 0;
     113        virtual void visit( TypeofType * typeofType ) = 0;
     114        virtual void visit( AttrType * attrType ) = 0;
     115        virtual void visit( VarArgsType * varArgsType ) = 0;
     116        virtual void visit( ZeroType * zeroType ) = 0;
     117        virtual void visit( OneType * oneType ) = 0;
     118        virtual void visit( GlobalScopeType * globalType ) = 0;
    206119
    207         virtual void visit( Designation * node ) { visit( const_cast<const Designation *>(node) ); }
    208         virtual void visit( const Designation * designation ) = 0;
    209         virtual void visit( SingleInit * node ) { visit( const_cast<const SingleInit *>(node) ); }
    210         virtual void visit( const SingleInit * singleInit ) = 0;
    211         virtual void visit( ListInit * node ) { visit( const_cast<const ListInit *>(node) ); }
    212         virtual void visit( const ListInit * listInit ) = 0;
    213         virtual void visit( ConstructorInit * node ) { visit( const_cast<const ConstructorInit *>(node) ); }
    214         virtual void visit( const ConstructorInit * ctorInit ) = 0;
     120        virtual void visit( Designation * designation ) = 0;
     121        virtual void visit( SingleInit * singleInit ) = 0;
     122        virtual void visit( ListInit * listInit ) = 0;
     123        virtual void visit( ConstructorInit * ctorInit ) = 0;
    215124
    216         virtual void visit( Constant * node ) { visit( const_cast<const Constant *>(node) ); }
    217         virtual void visit( const Constant * constant ) = 0;
     125        virtual void visit( Constant * constant ) = 0;
    218126
    219         virtual void visit( Attribute * node ) { visit( const_cast<const Attribute *>(node) ); }
    220         virtual void visit( const Attribute * attribute ) = 0;
     127        virtual void visit( Attribute * attribute ) = 0;
    221128};
    222129

  • src/Tuples/Explode.h

    rfce4e31 r302d84c2  
    5151        template<typename OutputIterator>
    5252        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
    53                         const ResolvExpr::OpenVarSet& openVars, const ResolvExpr::AssertionList& need,
     53                        const ResolvExpr::OpenVarSet& openVars, const ResolvExpr::AssertionList& need, 
    5454                        const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
    5555                *out++ = ResolvExpr::Alternative{ expr, env, openVars, need, cost, cvtCost };
    … …  
    5858        /// Append alternative to an ExplodedActual
    5959        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
    60                         const ResolvExpr::TypeEnvironment&, const ResolvExpr::OpenVarSet&,
     60                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::OpenVarSet&, 
    6161                        const ResolvExpr::AssertionList&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
    6262                ea.exprs.emplace_back( expr );
    … …  
    111111                } else {
    112112                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
    113                         append( std::forward<Output>(out), expr->clone(), alt.env, alt.openVars, alt.need,
     113                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.openVars, alt.need, 
    114114                                alt.cost, alt.cvtCost );
    115115                }
    … …  
    174174template< typename Output >
    175175void explodeRecursive(
    176         const ast::CastExpr *, const ResolvExpr::Candidate &,
    177         const ast::SymbolTable &, Output &&
     176        const ast::CastExpr * expr, const ResolvExpr::Candidate & arg,
     177        const ast::SymbolTable & symtab, Output && out
    178178) {
    179179}
    … …  
    240240/// explode list of candidates into flattened list of candidates
    241241template< typename Output >
    242 void explode(
    243         const ResolvExpr::CandidateList & cands, const ast::SymbolTable & symtab, Output && out,
     242void explode( 
     243        const ResolvExpr::CandidateList & cands, const ast::SymbolTable & symtab, Output && out, 
    244244        bool isTupleAssign = false
    245245) {

  • src/Tuples/TupleAssignment.cc

    rfce4e31 r302d84c2  
    6767                struct Matcher {
    6868                  public:
    69                         Matcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
     69                        Matcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs, 
    7070                                const ResolvExpr::AltList& rhs );
    7171                        virtual ~Matcher() {}
    72 
     72                       
    7373                        virtual void match( std::list< Expression * > &out ) = 0;
    7474                        ObjectDecl * newObject( UniqueName & namer, Expression * expr );
    … …  
    8383                                for ( const ResolvExpr::Alternative& alt : alts ) { combineState( alt ); }
    8484                        }
    85 
     85                       
    8686                        ResolvExpr::AltList lhs, rhs;
    8787                        TupleAssignSpotter_old &spotter;
    … …  
    264264                }
    265265
    266                 // extract expressions from the assignment alternatives to produce a list of assignments
     266                // extract expressions from the assignment alternatives to produce a list of assignments 
    267267                // that together form a single alternative
    268268                std::list< Expression *> solved_assigns;
    … …  
    271271                        matcher->combineState( alt );
    272272                }
    273 
     273               
    274274                // xxx -- was push_front
    275275                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative{
    276                         new TupleAssignExpr{ solved_assigns, matcher->tmpDecls }, matcher->compositeEnv,
    277                         matcher->openVars,
    278                         ResolvExpr::AssertionList( matcher->need.begin(), matcher->need.end() ),
     276                        new TupleAssignExpr{ solved_assigns, matcher->tmpDecls }, matcher->compositeEnv, 
     277                        matcher->openVars, 
     278                        ResolvExpr::AssertionList( matcher->need.begin(), matcher->need.end() ), 
    279279                        ResolvExpr::sumCost( current ) + matcher->baseCost } );
    280280        }
    … …  
    284284        : lhs(lhs), rhs(rhs), spotter(spotter),
    285285          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
    286                 combineState( lhs );
     286                combineState( lhs ); 
    287287                combineState( rhs );
    288288        }
    … …  
    390390                return dynamic_cast< const ast::TupleType * >( expr->result->stripReferences() );
    391391        }
    392 
     392       
    393393        /// true if `expr` is of tuple type or a reference to one
    394394        bool refToTuple( const ast::Expr * expr ) {
    … …  
    421421                        }
    422422
    423                         Matcher(
     423                        Matcher( 
    424424                                TupleAssignSpotter_new & s, const CodeLocation & loc,
    425425                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
    426                         : lhs( l ), rhs( r ), spotter( s ), location( loc ),
    427                           baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ), tmpDecls(),
     426                        : lhs( l ), rhs( r ), spotter( s ), location( loc ), 
     427                          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ), tmpDecls(), 
    428428                          env(), open(), need() {
    429429                                for ( auto & cand : lhs ) combineState( *cand );
    430430                                for ( auto & cand : rhs ) combineState( *cand );
    431431                        }
    432                         virtual ~Matcher() = default;
    433432
    434433                        virtual std::vector< ast::ptr< ast::Expr > > match() = 0;
    435434
    436                         /// removes environments from subexpressions within statement expressions, which could
    437                         /// throw off later passes like those in Box which rely on PolyMutator, and adds the
     435                        /// removes environments from subexpressions within statement expressions, which could 
     436                        /// throw off later passes like those in Box which rely on PolyMutator, and adds the 
    438437                        /// bindings to the env
    439438                        struct EnvRemover {
    … …  
    456455                        ast::ObjectDecl * newObject( UniqueName & namer, const ast::Expr * expr ) {
    457456                                assert( expr->result && ! expr->result->isVoid() );
    458 
    459                                 ast::ObjectDecl * ret = new ast::ObjectDecl{
    460                                         location, namer.newName(), expr->result, new ast::SingleInit{ location, expr },
     457                               
     458                                ast::ObjectDecl * ret = new ast::ObjectDecl{ 
     459                                        location, namer.newName(), expr->result, new ast::SingleInit{ location, expr }, 
    461460                                        ast::Storage::Classes{}, ast::Linkage::Cforall };
    462 
     461                               
    463462                                // if expression type is a reference, just need an initializer, otherwise construct
    464463                                if ( ! expr->result.as< ast::ReferenceType >() ) {
    465464                                        // resolve ctor/dtor for the new object
    466                                         ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit(
     465                                        ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit( 
    467466                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
    468467                                        // remove environments from subexpressions of stmtExpr
    … …  
    475474                        }
    476475
    477                         ast::UntypedExpr * createFunc(
    478                                 const std::string & fname, const ast::ObjectDecl * left,
    479                                 const ast::ObjectDecl * right
     476                        ast::UntypedExpr * createFunc( 
     477                                const std::string & fname, const ast::ObjectDecl * left, 
     478                                const ast::ObjectDecl * right 
    480479                        ) {
    481480                                assert( left );
    … …  
    487486                                        args.front() = new ast::AddressExpr{ location, args.front() };
    488487                                        if ( right ) { args.back() = new ast::AddressExpr{ location, args.back() }; }
    489                                         return new ast::UntypedExpr{
     488                                        return new ast::UntypedExpr{ 
    490489                                                location, new ast::NameExpr{ location, "?=?" }, std::move(args) };
    491490                                } else {
    492                                         return new ast::UntypedExpr{
     491                                        return new ast::UntypedExpr{ 
    493492                                                location, new ast::NameExpr{ location, fname }, std::move(args) };
    494493                                }
    … …  
    499498                struct MassAssignMatcher final : public Matcher {
    500499                        MassAssignMatcher(
    501                                 TupleAssignSpotter_new & s, const CodeLocation & loc,
     500                                TupleAssignSpotter_new & s, const CodeLocation & loc, 
    502501                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
    503502                        : Matcher( s, loc, l, r ) {}
    … …  
    509508                                assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
    510509
    511                                 ast::ptr< ast::ObjectDecl > rtmp =
     510                                ast::ptr< ast::ObjectDecl > rtmp = 
    512511                                        rhs.size() == 1 ? newObject( rhsNamer, rhs.front()->expr ) : nullptr;
    513512
    514513                                std::vector< ast::ptr< ast::Expr > > out;
    515514                                for ( ResolvExpr::CandidateRef & lhsCand : lhs ) {
    516                                         // create a temporary object for each value in the LHS and create a call
     515                                        // create a temporary object for each value in the LHS and create a call 
    517516                                        // involving the RHS
    518517                                        ast::ptr< ast::ObjectDecl > ltmp = newObject( lhsNamer, lhsCand->expr );
    … …  
    529528                struct MultipleAssignMatcher final : public Matcher {
    530529                        MultipleAssignMatcher(
    531                                 TupleAssignSpotter_new & s, const CodeLocation & loc,
     530                                TupleAssignSpotter_new & s, const CodeLocation & loc, 
    532531                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
    533532                        : Matcher( s, loc, l, r ) {}
    … …  
    539538                                if ( lhs.size() != rhs.size() ) return {};
    540539
    541                                 // produce a new temporary object for each value in the LHS and RHS and pairwise
     540                                // produce a new temporary object for each value in the LHS and RHS and pairwise 
    542541                                // create the calls
    543542                                std::vector< ast::ptr< ast::ObjectDecl > > ltmp, rtmp;
    … …  
    548547                                        ResolvExpr::CandidateRef & rhsCand = rhs[i];
    549548
    550                                         // convert RHS to LHS type minus one reference -- important for case where LHS
     549                                        // convert RHS to LHS type minus one reference -- important for case where LHS 
    551550                                        // is && and RHS is lvalue
    552551                                        auto lhsType = lhsCand->expr->result.strict_as< ast::ReferenceType >();
    … …  
    558557                                        rtmp.emplace_back( std::move( robj ) );
    559558
    560                                         // resolve the cast expression so that rhsCand return type is bound by the cast
     559                                        // resolve the cast expression so that rhsCand return type is bound by the cast 
    561560                                        // type as needed, and transfer the resulting environment
    562561                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env };
    … …  
    565564                                        env = std::move( finder.candidates.front()->env );
    566565                                }
    567 
     566                               
    568567                                splice( tmpDecls, ltmp );
    569568                                splice( tmpDecls, rtmp );
    570 
     569                               
    571570                                return out;
    572571                        }
    … …  
    576575                std::string fname;
    577576                std::unique_ptr< Matcher > matcher;
    578 
     577       
    579578        public:
    580                 TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f )
     579                TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f ) 
    581580                : crntFinder( f ), fname(), matcher() {}
    582581
    583582                // find left- and right-hand-sides for mass or multiple assignment
    584                 void spot(
    585                         const ast::UntypedExpr * expr, std::vector< ResolvExpr::CandidateFinder > & args
     583                void spot( 
     584                        const ast::UntypedExpr * expr, std::vector< ResolvExpr::CandidateFinder > & args 
    586585                ) {
    587586                        if ( auto op = expr->func.as< ast::NameExpr >() ) {
    … …  
    600599                                        if ( ! refToTuple( lhsCand->expr ) ) continue;
    601600
    602                                         // explode is aware of casts - ensure every LHS is sent into explode with a
     601                                        // explode is aware of casts - ensure every LHS is sent into explode with a 
    603602                                        // reference cast
    604603                                        if ( ! lhsCand->expr.as< ast::CastExpr >() ) {
    605                                                 lhsCand->expr = new ast::CastExpr{
     604                                                lhsCand->expr = new ast::CastExpr{ 
    606605                                                        lhsCand->expr, new ast::ReferenceType{ lhsCand->expr->result } };
    607606                                        }
    … …  
    611610                                        explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
    612611                                        for ( ResolvExpr::CandidateRef & cand : lhs ) {
    613                                                 // each LHS value must be a reference - some come in with a cast, if not
     612                                                // each LHS value must be a reference - some come in with a cast, if not 
    614613                                                // just cast to reference here
    615614                                                if ( ! cand->expr->result.as< ast::ReferenceType >() ) {
    … …  
    630629                                                                // multiple assignment
    631630                                                                explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
    632                                                                 matcher.reset(
     631                                                                matcher.reset( 
    633632                                                                        new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
    634633                                                        } else {
    635634                                                                // mass assignment
    636635                                                                rhs.emplace_back( rhsCand );
    637                                                                 matcher.reset(
     636                                                                matcher.reset( 
    638637                                                                        new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
    639638                                                        }
    … …  
    643642                                                // expand all possible RHS possibilities
    644643                                                std::vector< ResolvExpr::CandidateList > rhsCands;
    645                                                 combos(
     644                                                combos( 
    646645                                                        std::next( args.begin(), 1 ), args.end(), back_inserter( rhsCands ) );
    647646                                                for ( const ResolvExpr::CandidateList & rhsCand : rhsCands ) {
    … …  
    649648                                                        ResolvExpr::CandidateList rhs;
    650649                                                        explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
    651                                                         matcher.reset(
     650                                                        matcher.reset( 
    652651                                                                new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
    653652                                                        match();
    … …  
    664663
    665664                        if ( ! ( matcher->lhs.empty() && matcher->rhs.empty() ) ) {
    666                                 // if both LHS and RHS are empty than this is the empty tuple case, wherein it's
    667                                 // okay for newAssigns to be empty. Otherwise, return early so that no new
     665                                // if both LHS and RHS are empty than this is the empty tuple case, wherein it's 
     666                                // okay for newAssigns to be empty. Otherwise, return early so that no new 
    668667                                // candidates are generated
    669668                                if ( newAssigns.empty() ) return;
    … …  
    693692                        }
    694693
    695                         // extract expressions from the assignment candidates to produce a list of assignments
     694                        // extract expressions from the assignment candidates to produce a list of assignments 
    696695                        // that together form a sigle candidate
    697696                        std::vector< ast::ptr< ast::Expr > > solved;
    … …  
    702701
    703702                        crntFinder.candidates.emplace_back( std::make_shared< ResolvExpr::Candidate >(
    704                                 new ast::TupleAssignExpr{
    705                                         matcher->location, std::move( solved ), std::move( matcher->tmpDecls ) },
    706                                 std::move( matcher->env ), std::move( matcher->open ), std::move( matcher->need ),
     703                                new ast::TupleAssignExpr{ 
     704                                        matcher->location, std::move( solved ), std::move( matcher->tmpDecls ) }, 
     705                                std::move( matcher->env ), std::move( matcher->open ), std::move( matcher->need ), 
    707706                                ResolvExpr::sumCost( crnt ) + matcher->baseCost ) );
    708707                }
    … …  
    710709} // anonymous namespace
    711710
    712 void handleTupleAssignment(
    713         ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign,
     711void handleTupleAssignment( 
     712        ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign, 
    714713        std::vector< ResolvExpr::CandidateFinder > & args
    715714) {
Note: See TracChangeset for help on using the changeset viewer.