Changeset b067d9b for src/InitTweak/InitTweak.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

773db65, 9421f3d8

Parents:

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

Message:

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

File:

• src/InitTweak/InitTweak.cc (modified) (32 diffs)

src/InitTweak/InitTweak.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// InitTweak.cc --
+//
+// Author           : Rob Schluntz
+// Created On       : Fri May 13 11:26:36 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jul 25 22:21:48 2019
+// Update Count     : 7
+//
+
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
@@ -4 +19 @@
 #include <iterator>                // for back_insert_iterator, back_inserter
 #include <memory>                  // for __shared_ptr
-
+#include <vector>
+
+#include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -26 +48 @@
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
 
-class UntypedValofExpr;
-
 namespace InitTweak {
         namespace {
@@ -67 +87 @@
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
+                struct InitFlattener_old : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
                                 visit_children = false;
@@ -75 +95 @@
                 };
 
-        }
+                struct InitFlattener_new : public ast::WithShortCircuiting {
+                        std::vector< ast::ptr< ast::Expr > > argList;
+
+                        void previsit( const ast::SingleInit * singleInit ) {
+                                visit_children = false;
+                                argList.emplace_back( singleInit->value );
+                        }
+                };
+
+        } // anonymous namespace
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                PassVisitor<InitFlattener_old> flattener;
                 maybeAccept( init, flattener );
                 return flattener.pass.argList;
@@ -95 +124 @@
         }
 
-        class InitExpander::ExpanderImpl {
+std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
+        ast::Pass< InitFlattener_new > flattener;
+        maybe_accept( init, flattener );
+        return std::move( flattener.pass.argList );
+}
+
+        class InitExpander_old::ExpanderImpl {
         public:
                 virtual ~ExpanderImpl() = default;
@@ -102 +137 @@
         };
 
-        class InitImpl : public InitExpander::ExpanderImpl {
+        class InitImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                InitImpl( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl() = default;
+                InitImpl_old( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl_old() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -119 +154 @@
         };
 
-        class ExprImpl : public InitExpander::ExpanderImpl {
+        class ExprImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                ExprImpl( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl() { delete arg; }
+                ExprImpl_old( Expression * expr ) : arg( expr ) {}
+                virtual ~ExprImpl_old() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -146 +181 @@
         };
 
-        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
-
-        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
-
-        std::list< Expression * > InitExpander::operator*() {
+        InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {}
+
+        InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {}
+
+        std::list< Expression * > InitExpander_old::operator*() {
                 return cur;
         }
 
-        InitExpander & InitExpander::operator++() {
+        InitExpander_old & InitExpander_old::operator++() {
                 cur = expander->next( indices );
                 return *this;
@@ -160 +195 @@
 
         // use array indices list to build switch statement
-        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+        void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) {
                 indices.push_back( index );
                 indices.push_back( dimension );
         }
 
-        void InitExpander::clearArrayIndices() {
+        void InitExpander_old::clearArrayIndices() {
                 deleteAll( indices );
                 indices.clear();
         }
 
-        bool InitExpander::addReference() {
+        bool InitExpander_old::addReference() {
                 bool added = false;
                 for ( Expression *& expr : cur ) {
@@ -201 +236 @@
 
                 template< typename OutIterator >
-                void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
+                void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
                         if ( idx == idxEnd ) return;
                         Expression * index = *idx++;
@@ -258 +293 @@
         // remaining elements.
         // To accomplish this, generate switch statement, consuming all of expander's elements
-        Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt();
@@ -271 +306 @@
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+        Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
                 return nullptr;
         }
 
-        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+        Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) {
                 return expander->buildListInit( dst, indices );
         }
+
+class InitExpander_new::ExpanderImpl {
+public:
+        virtual ~ExpanderImpl() = default;
+        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
+        virtual ast::ptr< ast::Stmt > buildListInit(
+                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
+};
+
+namespace {
+        template< typename Out >
+        void buildCallExpr(
+                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension,
+                const ast::Init * init, Out & out
+        ) {
+                const CodeLocation & loc = init->location;
+
+                auto cond = new ast::UntypedExpr{
+                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
+
+                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
+                splice( callExpr->args, args );
+
+                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
+
+                out.emplace_back( new ast::ExprStmt{
+                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
+        }
+
+        template< typename Out >
+        void build(
+                ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices,
+                const ast::Init * init, Out & out
+        ) {
+                if ( indices.empty() ) return;
+
+                unsigned idx = 0;
+
+                const ast::Expr * index = indices[idx++];
+                assert( idx != indices.size() );
+                const ast::Expr * dimension = indices[idx++];
+
+                if ( idx == indices.size() ) {
+                        if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
+                                for ( const ast::Init * init : *listInit ) {
+                                        buildCallExpr( callExpr, index, dimension, init, out );
+                                }
+                        } else {
+                                buildCallExpr( callExpr, index, dimension, init, out );
+                        }
+                } else {
+                        const CodeLocation & loc = init->location;
+
+                        unsigned long cond = 0;
+                        auto listInit = dynamic_cast< const ast::ListInit * >( init );
+                        if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
+
+                        static UniqueName targetLabel( "L__autogen__" );
+                        ast::Label switchLabel{
+                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
+
+                        std::vector< ast::ptr< ast::Stmt > > branches;
+                        for ( const ast::Init * init : *listInit ) {
+                                auto condition = ast::ConstantExpr::from_ulong( loc, cond );
+                                ++cond;
+
+                                std::vector< ast::ptr< ast::Stmt > > stmts;
+                                build( callExpr, indices, init, stmts );
+                                stmts.emplace_back(
+                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
+                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+                        }
+                        out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
+                        out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
+                }
+        }
+
+        class InitImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Init > init;
+        public:
+                InitImpl_new( const ast::Init * i ) : init( i ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override {
+                        return makeInitList( init );
+                }
+
+                ast::ptr< ast::Stmt > buildListInit(
+                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices
+                ) override {
+                        // If array came with an initializer list, initialize each element. We may have more
+                        // initializers than elements of the array; need to check at each index that we have
+                        // not exceeded size. We may have fewer initializers than elements in the array; need
+                        // to default-construct remaining elements. To accomplish this, generate switch
+                        // statement consuming all of expander's elements
+
+                        if ( ! init ) return {};
+
+                        std::list< ast::ptr< ast::Stmt > > stmts;
+                        build( callExpr, indices, init, stmts );
+                        if ( stmts.empty() ) {
+                                return {};
+                        } else {
+                                auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
+                                init = nullptr;  // consumed in creating the list init
+                                return block;
+                        }
+                }
+        };
+
+        class ExprImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Expr > arg;
+        public:
+                ExprImpl_new( const ast::Expr * a ) : arg( a ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next(
+                        InitExpander_new::IndexList & indices
+                ) override {
+                        if ( ! arg ) return {};
+
+                        const CodeLocation & loc = arg->location;
+                        const ast::Expr * expr = arg;
+                        for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                // go through indices and layer on subscript exprs ?[?]
+                                ++it;
+                                expr = new ast::UntypedExpr{
+                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
+                        }
+                        return { expr };
+                }
+
+                ast::ptr< ast::Stmt > buildListInit(
+                        ast::UntypedExpr *, InitExpander_new::IndexList &
+                ) override {
+                        return {};
+                }
+        };
+} // anonymous namespace
+
+InitExpander_new::InitExpander_new( const ast::Init * init )
+: expander( new InitImpl_new{ init } ), crnt(), indices() {}
+
+InitExpander_new::InitExpander_new( const ast::Expr * expr )
+: expander( new ExprImpl_new{ expr } ), crnt(), indices() {}
+
+std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; }
+
+InitExpander_new & InitExpander_new::operator++ () {
+        crnt = expander->next( indices );
+        return *this;
+}
+
+/// builds statement which has the same semantics as a C-style list initializer (for array
+/// initializers) using callExpr as the base expression to perform initialization
+ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
+        return expander->buildListInit( callExpr, indices );
+}
+
+void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) {
+        indices.emplace_back( index );
+        indices.emplace_back( dimension );
+}
+
+void InitExpander_new::clearArrayIndices() { indices.clear(); }
+
+bool InitExpander_new::addReference() {
+        for ( ast::ptr< ast::Expr > & expr : crnt ) {
+                expr = new ast::AddressExpr{ expr };
+        }
+        return ! crnt.empty();
+}
 
         Type * getTypeofThis( FunctionType * ftype ) {
@@ -306 +511 @@
         }
 
-        struct CallFinder {
-                CallFinder( const std::list< std::string > & names ) : names( names ) {}
+        struct CallFinder_old {
+                CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
 
                 void postvisit( ApplicationExpr * appExpr ) {
@@ -330 +535 @@
         };
 
+        struct CallFinder_new final {
+                std::vector< ast::ptr< ast::Expr > > matches;
+                const std::vector< std::string > names;
+
+                CallFinder_new( std::vector< std::string > && ns ) : matches(), names( std::move(ns) ) {}
+
+                void handleCallExpr( const ast::Expr * expr ) {
+                        std::string fname = getFunctionName( expr );
+                        if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
+                                matches.emplace_back( expr );
+                        }
+                }
+
+                void postvisit( const ast::ApplicationExpr * expr ) { handleCallExpr( expr ); }
+                void postvisit( const ast::UntypedExpr *     expr ) { handleCallExpr( expr ); }
+        };
+
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
-                static PassVisitor<CallFinder> finder( std::list< std::string >{ "?{}", "^?{}" } );
+                static PassVisitor<CallFinder_old> finder( std::list< std::string >{ "?{}", "^?{}" } );
                 finder.pass.matches = &matches;
                 maybeAccept( stmt, finder );
+        }
+
+        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+                ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
+                maybe_accept( stmt, finder );
+                return std::move( finder.pass.matches );
         }
 
@@ -339 +567 @@
                 std::list< Expression * > matches;
                 collectCtorDtorCalls( stmt, matches );
-                assert( matches.size() <= 1 );
+                assertf( matches.size() <= 1, "%zd constructor/destructors found in %s", matches.size(), toString( stmt ).c_str() );
                 return matches.size() == 1 ? matches.front() : nullptr;
         }
@@ -345 +573 @@
         namespace {
                 DeclarationWithType * getCalledFunction( Expression * expr );
+                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr );
 
                 template<typename CallExpr>
@@ -354 +583 @@
                         return getCalledFunction( expr->get_args().front() );
                 }
+
+                template<typename CallExpr>
+                const ast::DeclWithType * handleDerefCalledFunction( const CallExpr * expr ) {
+                        // (*f)(x) => should get "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->args.empty(), "Cannot get called function from dereference with no arguments" );
+                        return getCalledFunction( expr->args.front() );
+                }
+
 
                 DeclarationWithType * getCalledFunction( Expression * expr ) {
@@ -374 +613 @@
                         return nullptr;
                 }
+
+                const ast::DeclWithType * getCalledFunction( const ast::Expr * expr ) {
+                        assert( expr );
+                        if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( expr ) ) {
+                                return varExpr->var;
+                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( expr ) ) {
+                                return memberExpr->member;
+                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( expr ) ) {
+                                return getCalledFunction( castExpr->arg );
+                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( expr ) ) {
+                                return handleDerefCalledFunction( untypedExpr );
+                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * > ( expr ) ) {
+                                return handleDerefCalledFunction( appExpr );
+                        } else if ( const ast::AddressExpr * addrExpr = dynamic_cast< const ast::AddressExpr * >( expr ) ) {
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( const ast::CommaExpr * commaExpr = dynamic_cast< const ast::CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
+                        }
+                        return nullptr;
+                }
+
+                DeclarationWithType * getFunctionCore( const Expression * expr ) {
+                        if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
+                                return getCalledFunction( appExpr->function );
+                        } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
+                                return getCalledFunction( untyped->function );
+                        }
+                        assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
+                }
         }
 
         DeclarationWithType * getFunction( Expression * expr ) {
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
-                        return getCalledFunction( appExpr->get_function() );
-                } else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * > ( expr ) ) {
-                        return getCalledFunction( untyped->get_function() );
+                return getFunctionCore( expr );
+        }
+
+        const DeclarationWithType * getFunction( const Expression * expr ) {
+                return getFunctionCore( expr );
+        }
+
+        const ast::DeclWithType * getFunction( const ast::Expr * expr ) {
+                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
+                        return getCalledFunction( appExpr->func );
+                } else if ( const ast::UntypedExpr * untyped = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
+                        return getCalledFunction( untyped->func );
                 }
                 assertf( false, "getFunction received unknown expression: %s", toString( expr ).c_str() );
@@ -395 +671 @@
         }
 
+        const ast::ApplicationExpr * isIntrinsicCallExpr( const ast::Expr * expr ) {
+                auto appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr );
+                if ( ! appExpr ) return nullptr;
+
+                const ast::DeclWithType * func = getCalledFunction( appExpr->func );
+                assertf( func,
+                        "getCalledFunction returned nullptr: %s", toString( appExpr->func ).c_str() );
+
+                // check for Intrinsic only -- don't want to remove all overridable ctor/dtor because
+                // autogenerated ctor/dtor will call all member dtors, and some members may have a
+                // user-defined dtor
+                return func->linkage == ast::Linkage::Intrinsic ? appExpr : nullptr;
+        }
+
         namespace {
                 template <typename Predicate>
@@ -403 +693 @@
                         return std::all_of( callExprs.begin(), callExprs.end(), pred);
                 }
+
+                template <typename Predicate>
+                bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
+                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        return std::all_of( callExprs.begin(), callExprs.end(), pred );
+                }
         }
 
@@ -408 +704 @@
                 return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
-                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_result() );
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->function->result );
                                 assert( funcType );
                                 return funcType->get_parameters().size() == 1;
+                        }
+                        return false;
+                });
+        }
+
+        bool isIntrinsicSingleArgCallStmt( const ast::Stmt * stmt ) {
+                return allofCtorDtor( stmt, []( const ast::Expr * callExpr ){
+                        if ( const ast::ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
+                                const ast::FunctionType * funcType =
+                                        GenPoly::getFunctionType( appExpr->func->result );
+                                assert( funcType );
+                                return funcType->params.size() == 1;
                         }
                         return false;
@@ -429 +737 @@
                                 if ( pos == 0 ) return arg;
                                 pos--;
+                        }
+                        assert( false );
+                }
+
+                template<typename CallExpr>
+                const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
+                        if( pos >= call->args.size() ) {
+                                assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
+                                        pos, toString( call ).c_str() );
+                        }
+                        for ( const ast::Expr * arg : call->args ) {
+                                if ( pos == 0 ) return arg;
+                                --pos;
                         }
                         assert( false );
@@ -453 +774 @@
         }
 
+        const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
+                if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
+                        return callArg( app, pos );
+                } else if ( auto untyped = dynamic_cast< const ast::UntypedExpr * >( call ) ) {
+                        return callArg( untyped, pos );
+                } else if ( auto tupleAssn = dynamic_cast< const ast::TupleAssignExpr * >( call ) ) {
+                        const std::list<ast::ptr<ast::Stmt>>& stmts = tupleAssn->stmtExpr->stmts->kids;
+                        assertf( ! stmts.empty(), "TupleAssignExpr missing statements." );
+                        auto stmt  = strict_dynamic_cast< const ast::ExprStmt * >( stmts.back().get() );
+                        auto tuple = strict_dynamic_cast< const ast::TupleExpr * >( stmt->expr.get() );
+                        assertf( ! tuple->exprs.empty(), "TupleAssignExpr has empty tuple expr.");
+                        return getCallArg( tuple->exprs.front(), pos );
+                } else if ( auto ctor = dynamic_cast< const ast::ImplicitCopyCtorExpr * >( call ) ) {
+                        return getCallArg( ctor->callExpr, pos );
+                } else {
+                        assertf( false, "Unexpected expression type passed to getCallArg: %s",
+                                toString( call ).c_str() );
+                }
+        }
+
         namespace {
                 std::string funcName( Expression * func );
+                std::string funcName( const ast::Expr * func );
 
                 template<typename CallExpr>
@@ -463 +805 @@
                         assertf( ! expr->get_args().empty(), "Cannot get function name from dereference with no arguments" );
                         return funcName( expr->get_args().front() );
+                }
+
+                template<typename CallExpr>
+                std::string handleDerefName( const CallExpr * expr ) {
+                        // (*f)(x) => should get name "f"
+                        std::string name = getFunctionName( expr );
+                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+                        assertf( ! expr->args.empty(), "Cannot get function name from dereference with no arguments" );
+                        return funcName( expr->args.front() );
                 }
 
@@ -486 +837 @@
                         }
                 }
+
+                std::string funcName( const ast::Expr * func ) {
+                        if ( const ast::NameExpr * nameExpr = dynamic_cast< const ast::NameExpr * >( func ) ) {
+                                return nameExpr->name;
+                        } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
+                                return varExpr->var->name;
+                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+                                return funcName( castExpr->arg );
+                        } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
+                                return memberExpr->member->name;
+                        } else if ( const ast::UntypedMemberExpr * memberExpr = dynamic_cast< const ast::UntypedMemberExpr * > ( func ) ) {
+                                return funcName( memberExpr->member );
+                        } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * >( func ) ) {
+                                return handleDerefName( untypedExpr );
+                        } else if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( func ) ) {
+                                return handleDerefName( appExpr );
+                        } else if ( const ast::ConstructorExpr * ctorExpr = dynamic_cast< const ast::ConstructorExpr * >( func ) ) {
+                                return funcName( getCallArg( ctorExpr->callExpr, 0 ) );
+                        } else {
+                                assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() );
+                        }
+                }
         }
 
@@ -502 +875 @@
         }
 
+        std::string getFunctionName( const ast::Expr * expr ) {
+                // there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
+                // return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
+                // can't possibly do anything reasonable.
+                if ( const ast::ApplicationExpr * appExpr = dynamic_cast< const ast::ApplicationExpr * >( expr ) ) {
+                        return funcName( appExpr->func );
+                } else if ( const ast::UntypedExpr * untypedExpr = dynamic_cast< const ast::UntypedExpr * > ( expr ) ) {
+                        return funcName( untypedExpr->func );
+                } else {
+                        std::cerr << expr << std::endl;
+                        assertf( false, "Unexpected expression type passed to getFunctionName" );
+                }
+        }
+
         Type * getPointerBase( Type * type ) {
                 if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
@@ -513 +900 @@
                 }
         }
+        const ast::Type* getPointerBase( const ast::Type* t ) {
+                if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
+                        return p->base;
+                } else if ( const auto * a = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                        return a->base;
+                } else if ( const auto * r = dynamic_cast< const ast::ReferenceType * >( t ) ) {
+                        return r->base;
+                } else return nullptr;
+        }
 
         Type * isPointerType( Type * type ) {
@@ -561 +957 @@
                 void previsit( OffsetofExpr * ) {}
                 void previsit( OffsetPackExpr * ) {}
-                void previsit( AttrExpr * ) {}
                 void previsit( CommaExpr * ) {}
                 void previsit( LogicalExpr * ) {}
@@ -609 +1004 @@
         bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
 
-        FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
-                FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
+        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
+                const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
                 if ( ! function ) return nullptr;
                 if ( function->name != fname ) return nullptr;
@@ -627 +1022 @@
         }
 
-        FunctionDecl * isAssignment( Declaration * decl ) {
+        bool isCopyFunction( const ast::FunctionDecl * decl ) {
+                const ast::FunctionType * ftype = decl->type;
+                if ( ftype->params.size() != 2 ) return false;
+
+                const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
+                if ( ! t1 ) return false;
+                const ast::Type * t2 = ftype->params.back()->get_type();
+
+                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
+        }
+
+        const FunctionDecl * isAssignment( const Declaration * decl ) {
                 return isCopyFunction( decl, "?=?" );
         }
-        FunctionDecl * isDestructor( Declaration * decl ) {
-                if ( isDestructor( decl->get_name() ) ) {
-                        return dynamic_cast< FunctionDecl * >( decl );
+        const FunctionDecl * isDestructor( const Declaration * decl ) {
+                if ( isDestructor( decl->name ) ) {
+                        return dynamic_cast< const FunctionDecl * >( decl );
                 }
                 return nullptr;
         }
-        FunctionDecl * isDefaultConstructor( Declaration * decl ) {
+        const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
                 if ( isConstructor( decl->name ) ) {
-                        if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
+                        if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
                                 if ( func->type->parameters.size() == 1 ) {
                                         return func;
@@ -646 +1052 @@
                 return nullptr;
         }
-        FunctionDecl * isCopyConstructor( Declaration * decl ) {
+        const FunctionDecl * isCopyConstructor( const Declaration * decl ) {
                 return isCopyFunction( decl, "?{}" );
         }