Changeset 33b7d49

Timestamp:

Mar 15, 2022, 10:14:05 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

48a91e2

Parents:

d824715

Message:

Added another check to checkInvariants for code locations. I also went through and made sure you can put it every after every new AST pass not followed by a forceFillCodeLocations.

Files:

• src/AST/Util.cpp (modified) (2 diffs)
• src/Common/CodeLocationTools.cpp (modified) (3 diffs)
• src/Common/CodeLocationTools.hpp (modified) (2 diffs)
• src/ControlStruct/ExceptTranslateNew.cpp (modified) (24 diffs)
• src/InitTweak/FixGlobalInit.cc (modified) (2 diffs)
• src/InitTweak/FixInitNew.cpp (modified) (6 diffs)
• src/main.cc (modified) (1 diff)
• tests/collections/.expect/vector-err-pass-perm-it-byval.txt (modified) (1 diff)

src/AST/Util.cpp

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

src/Common/CodeLocationTools.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Fri Dec  4 15:42:00 2020
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 09:14:39 2022
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar 14 15:14:00 2022
+// Update Count     : 4
 //
 
@@ -239 +239 @@
 };
 
+class LocalFillCore : public ast::WithGuards {
+        CodeLocation const * parent;
+public:
+        LocalFillCore( CodeLocation const & location ) : parent( &location ) {
+                assert( location.isSet() );
+        }
+
+        template<typename node_t>
+        auto previsit( node_t const * node )
+                        -> typename std::enable_if<has_code_location<node_t>::value, node_t const *>::type {
+                if ( node->location.isSet() ) {
+                        GuardValue( parent ) = &node->location;
+                        return node;
+                } else {
+                        node_t * mut = ast::mutate( node );
+                        mut->location = *parent;
+                        return mut;
+                }
+        }
+};
+
 } // namespace
 
@@ -278 +299 @@
         ast::Pass<FillCore>::run( unit );
 }
+
+ast::Node const * localFillCodeLocations(
+                CodeLocation const & location , ast::Node const * node ) {
+        ast::Pass<LocalFillCore> visitor( location );
+        return node->accept( visitor );
+}

src/Common/CodeLocationTools.hpp

@@ -10 +10 @@
 // Created On       : Fri Dec  4 15:35:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Dec  9  9:53:00 2020
-// Update Count     : 1
+// Last Modified On : Mon Mar 14 15:14:00 2022
+// Update Count     : 2
 //
 
 #pragma once
 
+class CodeLocation;
 namespace ast {
+        class Node;
         class TranslationUnit;
 }
@@ -28 +30 @@
 // Assign a nearby code-location to any unset code locations in the forest.
 void forceFillCodeLocations( ast::TranslationUnit & unit );
+
+// Fill in code-locations with a parent code location,
+// using the provided CodeLocation as the base.
+ast::Node const *
+        localFillCodeLocations( CodeLocation const &, ast::Node const * );

src/ControlStruct/ExceptTranslateNew.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  8 11:53:00 2021
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 18:49:58 2022
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 11 17:51:00 2022
+// Update Count     : 2
 //
 
@@ -27 +27 @@
 
         typedef std::list<ast::CatchStmt*> CatchList;
-
-        void split( CatchList& allHandlers, CatchList& terHandlers,
-                                CatchList& resHandlers ) {
-                while ( !allHandlers.empty() ) {
-                        ast::CatchStmt * stmt = allHandlers.front();
-                        allHandlers.pop_front();
-                        if (stmt->kind == ast::ExceptionKind::Terminate) {
-                                terHandlers.push_back(stmt);
-                        } else {
-                                resHandlers.push_back(stmt);
-                        }
-                }
-        }
 
         void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
@@ -171 +158 @@
         ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );
 
-        // Types used in translation, make sure to use clone.
+        // Types used in translation, first group are internal.
+        ast::ObjectDecl * make_index_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_exception_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_bool_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_voidptr_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_unused_index_object( CodeLocation const & ) const;
         // void (*function)();
-        ast::FunctionDecl * try_func_t;
+        ast::FunctionDecl * make_try_function( CodeLocation const & ) const;
         // void (*function)(int, exception);
-        ast::FunctionDecl * catch_func_t;
+        ast::FunctionDecl * make_catch_function( CodeLocation const & ) const;
         // int (*function)(exception);
-        ast::FunctionDecl * match_func_t;
+        ast::FunctionDecl * make_match_function( CodeLocation const & ) const;
         // bool (*function)(exception);
-        ast::FunctionDecl * handle_func_t;
+        ast::FunctionDecl * make_handle_function( CodeLocation const & ) const;
         // void (*function)(__attribute__((unused)) void *);
-        ast::FunctionDecl * finally_func_t;
-
-        ast::StructInstType * create_except_type() {
-                assert( except_decl );
-                return new ast::StructInstType( except_decl );
-        }
-        void init_func_types();
+        ast::FunctionDecl * make_finally_function( CodeLocation const & ) const;
 
 public:
@@ -199 +185 @@
 };
 
-void TryMutatorCore::init_func_types() {
+ast::ObjectDecl * TryMutatorCore::make_index_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
+                "__handler_index",
+                new ast::BasicType(ast::BasicType::SignedInt),
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                );
+}
+
+ast::ObjectDecl * TryMutatorCore::make_exception_object(
+                CodeLocation const & location ) const {
         assert( except_decl );
-
-        ast::ObjectDecl index_obj(
-                {},
-                "__handler_index",
-                new ast::BasicType(ast::BasicType::SignedInt)
-                );
-        ast::ObjectDecl exception_obj(
-                {},
+        return new ast::ObjectDecl(
+                location,
                 "__exception_inst",
                 new ast::PointerType(
                         new ast::StructInstType( except_decl )
                         ),
-                NULL
-                );
-        ast::ObjectDecl bool_obj(
-                {},
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                );
+}
+
+ast::ObjectDecl * TryMutatorCore::make_bool_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__ret_bool",
                 new ast::BasicType( ast::BasicType::Bool ),
@@ -225 +224 @@
                 std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                 );
-        ast::ObjectDecl voidptr_obj(
-                {},
+}
+
+ast::ObjectDecl * TryMutatorCore::make_voidptr_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__hook",
                 new ast::PointerType(
@@ -237 +240 @@
                 std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                 );
-
-        ast::ObjectDecl unused_index_obj(
-                {},
+}
+
+ast::ObjectDecl * TryMutatorCore::make_unused_index_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__handler_index",
                 new ast::BasicType(ast::BasicType::SignedInt),
@@ -248 +254 @@
                 std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
         );
-        //unused_index_obj->attributes.push_back( new Attribute( "unused" ) );
-
-        try_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_try_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "try",
                 {}, //forall
@@ -260 +268 @@
                 ast::Linkage::Cforall
         );
-
-        catch_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_catch_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "catch",
                 {}, //forall
-                {ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
+                { make_index_object( location ), make_exception_object( location ) },
                 {}, //return void
                 nullptr,
@@ -271 +282 @@
                 ast::Linkage::Cforall
         );
-
-        match_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_match_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "match",
                 {}, //forall
-                {ast::deepCopy(&exception_obj)},
-                {ast::deepCopy(&unused_index_obj)},
+                { make_exception_object( location ) },
+                { make_unused_index_object( location ) },
                 nullptr,
                 ast::Storage::Classes{},
                 ast::Linkage::Cforall
         );
-
-        handle_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_handle_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "handle",
                 {}, //forall
-                {ast::deepCopy(&exception_obj)},
-                {ast::deepCopy(&bool_obj)},
+                { make_exception_object( location ) },
+                { make_bool_object( location ) },
                 nullptr,
                 ast::Storage::Classes{},
                 ast::Linkage::Cforall
         );
-
-        finally_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_finally_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "finally",
                 {}, //forall
-                {ast::deepCopy(&voidptr_obj)},
+                { make_voidptr_object( location ) },
                 {}, //return void
                 nullptr,
@@ -304 +324 @@
                 ast::Linkage::Cforall
         );
-
-        //catch_func_t.get_parameters().push_back( index_obj.clone() );
-        //catch_func_t.get_parameters().push_back( exception_obj.clone() );
-        //match_func_t.get_returnVals().push_back( unused_index_obj );
-        //match_func_t.get_parameters().push_back( exception_obj.clone() );
-        //handle_func_t.get_returnVals().push_back( bool_obj.clone() );
-        //handle_func_t.get_parameters().push_back( exception_obj.clone() );
-        //finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
 }
 
 // TryStmt Mutation Helpers
-
-/*
-ast::CompoundStmt * TryMutatorCore::take_try_block( ast::TryStmt *tryStmt ) {
-        ast::CompoundStmt * block = tryStmt->body;
-        tryStmt->body = nullptr;
-        return block;
-}
-*/
 
 ast::FunctionDecl * TryMutatorCore::create_try_wrapper(
                 const ast::CompoundStmt *body ) {
 
-        ast::FunctionDecl * ret = ast::deepCopy(try_func_t);
+        ast::FunctionDecl * ret = make_try_function( body->location );
         ret->stmts = body;
         return ret;
@@ -339 +343 @@
         const CodeLocation loc = handlers.front()->location;
 
-        ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
+        ast::FunctionDecl * func_t = make_catch_function( loc );
         const ast::DeclWithType * index_obj = func_t->params.front();
         const ast::DeclWithType * except_obj = func_t->params.back();
@@ -386 +390 @@
                 // handler->body = nullptr;
 
-                handler_wrappers.push_back( new ast::CaseStmt(loc, 
+                handler_wrappers.push_back( new ast::CaseStmt(loc,
                         ast::ConstantExpr::from_int(loc, index) ,
                         { block, new ast::ReturnStmt( loc, nullptr ) }
@@ -393 +397 @@
         // TODO: Some sort of meaningful error on default perhaps?
 
-        /*
-        std::list<Statement*> stmt_handlers;
-        while ( !handler_wrappers.empty() ) {
-                stmt_handlers.push_back( handler_wrappers.front() );
-                handler_wrappers.pop_front();
-        }
-        */
-
-        ast::SwitchStmt * handler_lookup = new ast::SwitchStmt(loc, 
+        ast::SwitchStmt * handler_lookup = new ast::SwitchStmt( loc,
                 new ast::VariableExpr( loc, index_obj ),
                 std::move(handler_wrappers)
                 );
-        ast::CompoundStmt * body = new ast::CompoundStmt(loc, 
-                {handler_lookup});
+        ast::CompoundStmt * body = new ast::CompoundStmt( loc, {handler_lookup} );
 
         func_t->stmts = body;
@@ -433 +428 @@
 
         // Check for type match.
-        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc, 
+        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
                 new ast::VariableExpr(loc, except_obj ),
                 local_except->get_type()
@@ -445 +440 @@
         }
         // Construct the match condition.
-        block->push_back( new ast::IfStmt(loc, 
+        block->push_back( new ast::IfStmt(loc,
                 cond, modded_handler->body, nullptr ) );
 
-        // xxx - how does this work in new ast
-        //modded_handler->set_decl( nullptr );
-        //modded_handler->set_cond( nullptr );
-        //modded_handler->set_body( nullptr );
-        //delete modded_handler;
         return block;
 }
@@ -467 +457 @@
         ast::CompoundStmt * body = new ast::CompoundStmt(loc);
 
-        ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
+        ast::FunctionDecl * func_t = make_match_function( loc );
         const ast::DeclWithType * except_obj = func_t->params.back();
 
@@ -490 +480 @@
         }
 
-        body->push_back( new ast::ReturnStmt(loc, 
+        body->push_back( new ast::ReturnStmt(loc,
                 ast::ConstantExpr::from_int( loc, 0 ) ));
 
@@ -525 +515 @@
         ast::CompoundStmt * body = new ast::CompoundStmt(loc);
 
-        ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
+        ast::FunctionDecl * func_t = make_handle_function( loc );
         const ast::DeclWithType * except_obj = func_t->params.back();
 
@@ -535 +525 @@
                 ast::CompoundStmt * handling_code;
                 if (handler->body.as<ast::CompoundStmt>()) {
-                        handling_code = 
-                        strict_dynamic_cast<ast::CompoundStmt*>( handler->body.get_and_mutate() );
+                        handling_code = strict_dynamic_cast<ast::CompoundStmt*>(
+                                handler->body.get_and_mutate() );
                 } else {
                         handling_code = new ast::CompoundStmt(loc);
@@ -600 +590 @@
         const ast::CompoundStmt * body = finally->body;
 
-        ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
+        ast::FunctionDecl * func_t = make_finally_function( tryStmt->location );
         func_t->stmts = body;
 
-        // finally->set_block( nullptr );
-        // delete finally;
         tryStmt->finally = nullptr;
-
 
         return func_t;
@@ -617 +604 @@
 
         const CodeLocation loc = finally_wrapper->location;
-        // Make Cleanup Attribute.
-        /*
-        std::list< ast::Attribute * > attributes;
-        {
-                std::list<  > attr_params;
-                attr_params.push_back( nameOf( finally_wrapper ) );
-                attributes.push_back( new Attribute( "cleanup", attr_params ) );
-        }
-        */
-
         return new ast::ObjectDecl(
                 loc,
@@ -644 +621 @@
         // return false;
         const CodeLocation loc = throwStmt->location;
-        ast::Stmt * result = new ast::ReturnStmt(loc, 
+        ast::Stmt * result = new ast::ReturnStmt(loc,
                 ast::ConstantExpr::from_bool( loc, false )
                 );
         result->labels = throwStmt->labels;
-        // delete throwStmt; done by postvisit
         return result;
 }
@@ -660 +636 @@
                 assert( nullptr == except_decl );
                 except_decl = structDecl;
-                init_func_types();
         } else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
                 assert( nullptr == node_decl );
@@ -706 +681 @@
                 }
         }
-        // split( mutStmt->handlers,
-        //              termination_handlers, resumption_handlers );
 
         if ( resumption_handlers.size() ) {

src/InitTweak/FixGlobalInit.cc

@@ -113 +113 @@
                 accept_all(translationUnit, fixer);
 
+                // Say these magic declarations come at the end of the file.
+                CodeLocation const & location = translationUnit.decls.back()->location;
+
                 if ( !fixer.core.initStmts.empty() ) {
                         std::vector<ast::ptr<ast::Expr>> ctorParams;
-                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
-                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)), 
-                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
+                        auto initFunction = new ast::FunctionDecl(location,
+                                "__global_init__", {}, {}, {},
+                                new ast::CompoundStmt(location, std::move(fixer.core.initStmts)),
+                                ast::Storage::Static, ast::Linkage::C,
+                                {new ast::Attribute("constructor", std::move(ctorParams))});
 
                         translationUnit.decls.emplace_back( initFunction );
@@ -124 +130 @@
                 if ( !fixer.core.destroyStmts.empty() ) {
                         std::vector<ast::ptr<ast::Expr>> dtorParams;
-                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
-                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)), 
-                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
+                        auto destroyFunction = new ast::FunctionDecl( location,
+                                "__global_destroy__", {}, {}, {},
+                                new ast::CompoundStmt(location, std::move(fixer.core.destroyStmts)),
+                                ast::Storage::Static, ast::Linkage::C,
+                                {new ast::Attribute("destructor", std::move(dtorParams))});
 
                         translationUnit.decls.emplace_back(destroyFunction);

src/InitTweak/FixInitNew.cpp

@@ -16 +16 @@
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
+#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
@@ -553 +554 @@
                 ast::ptr<ast::Expr> guard = mutArg;
 
-                ast::ptr<ast::ObjectDecl> tmp = new ast::ObjectDecl({}, "__tmp", mutResult, nullptr );
+                ast::ptr<ast::ObjectDecl> tmp = new ast::ObjectDecl(loc, "__tmp", mutResult, nullptr );
 
                 // create and resolve copy constructor
@@ -799 +800 @@
         // to prevent warnings ('_unq0' may be used uninitialized in this function),
         // insert an appropriate zero initializer for UniqueExpr temporaries.
-        ast::Init * makeInit( const ast::Type * t ) {
+        ast::Init * makeInit( const ast::Type * t, CodeLocation const & loc ) {
                 if ( auto inst = dynamic_cast< const ast::StructInstType * >( t ) ) {
                         // initizer for empty struct must be empty
-                        if ( inst->base->members.empty() ) return new ast::ListInit({}, {});
+                        if ( inst->base->members.empty() ) {
+                                return new ast::ListInit( loc, {} );
+                        }
                 } else if ( auto inst = dynamic_cast< const ast::UnionInstType * >( t ) ) {
                         // initizer for empty union must be empty
-                        if ( inst->base->members.empty() ) return new ast::ListInit({}, {});
-                }
-
-                return new ast::ListInit( {}, { new ast::SingleInit( {}, ast::ConstantExpr::from_int({}, 0) ) } );
+                        if ( inst->base->members.empty() ) {
+                                return new ast::ListInit( loc, {} );
+                        }
+                }
+
+                return new ast::ListInit( loc, {
+                        new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) )
+                } );
         }
 
@@ -832 +839 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                mutExpr->object = new ast::ObjectDecl( mutExpr->location, toString("_unq", mutExpr->id), mutExpr->result, makeInit( mutExpr->result ) );
+                                mutExpr->object = new ast::ObjectDecl( mutExpr->location, toString("_unq", mutExpr->id), mutExpr->result, makeInit( mutExpr->result, mutExpr->location ) );
                                 mutExpr->var = new ast::VariableExpr( mutExpr->location, mutExpr->object );
                         }
@@ -1229 +1236 @@
 
                                                         auto destructor = new ast::ObjectDecl(loc, memberDtorNamer.newName(), new ast::StructInstType( ast::dtorStruct ), new ast::ListInit(loc, { new ast::SingleInit(loc, thisExpr ), new ast::SingleInit(loc, new ast::CastExpr( dtorExpr, dtorType ) ) } ) );
-                                                        destructor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr({}, ast::dtorStructDestroy ) } ) );
+                                                        destructor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr( loc, ast::dtorStructDestroy ) } ) );
                                                         mutStmts->push_front( new ast::DeclStmt(loc, destructor ) );
                                                         mutStmts->kids.splice( mutStmts->kids.begin(), stmtsToAdd );
@@ -1323 +1330 @@
 
         const ast::Expr * GenStructMemberCalls::postvisit( const ast::UntypedExpr * untypedExpr ) {
-                // Expression * newExpr = untypedExpr;
                 // xxx - functions returning ast::ptr seems wrong...
                 auto res = ResolvExpr::findVoidExpression( untypedExpr, symtab );
-                return res.release();
-                // return newExpr;
+                // Fix CodeLocation (at least until resolver is fixed).
+                auto fix = localFillCodeLocations( untypedExpr->location, res.release() );
+                return strict_dynamic_cast<const ast::Expr *>( fix );
         }
 

src/main.cc

@@ -32 +32 @@
 
 #include "AST/Convert.hpp"
-#include "AST/Print.hpp"
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR

tests/collections/.expect/vector-err-pass-perm-it-byval.txt

@@ -1 @@
-error: Unique best alternative includes deleted identifier in Generated Cast of:
+collections/vector-demo.cfa:95:1 error: Unique best alternative includes deleted identifier in Generated Cast of:
   Application of
     Deleted Expression