Changes in src/ResolvExpr/Resolver.cc [99d4584:2b59f55]

File:

• src/ResolvExpr/Resolver.cc (modified) (14 diffs)

src/ResolvExpr/Resolver.cc

@@ -29 +29 @@
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "AST/Chain.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
@@ -164 +165 @@
                 void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
                         if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
+                                if ( typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
                                         // cast is to the same type as its argument, so it's unnecessary -- remove it
                                         expr = castExpr->arg;
@@ -410 +411 @@
 
         void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
+                // class-variable initContext is changed multiple time because the LHS is analysed twice.
+                // The second analysis changes initContext because of a function type can contain object
+                // declarations in the return and parameter types. So each value of initContext is
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -450 +451 @@
 
         void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I
@@ -964 +965 @@
                 }
 
+                /// always-accept candidate filter
+                bool anyCandidate( const Candidate & ) { return true; }
+
                 /// Calls the CandidateFinder and finds the single best candidate
                 CandidateRef findUnfinishedKindExpression(
                         const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, 
-                        std::function<bool(const Candidate &)> pred, ResolvMode mode = {}
+                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
                 ) {
                         if ( ! untyped ) return nullptr;
@@ -1055 +1059 @@
                                 ) {
                                         // generated cast is the same type as its argument, remove it after keeping env
-                                        ast::ptr<ast::Expr> arg = castExpr->arg;
-                                        arg.get_and_mutate()->env = castExpr->env;
-                                        return arg;
+                                        return ast::mutate_field( 
+                                                castExpr->arg.get(), &ast::Expr::env, castExpr->env );
                                 }
                                 return castExpr;
@@ -1067 +1070 @@
                         }
                 };
+
+                /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
+                void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
+                        if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
+                                if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
+                                        // cast is to the same type as its argument, remove it
+                                        ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                        expr.set_and_mutate( castExpr->arg )->env = env;
+                                }
+                        }
+                }
 
                 /// Establish post-resolver invariants for expressions
@@ -1081 +1095 @@
                         StripCasts_new::strip( expr );
                 }
-                
+
+                /// Find the expression candidate that is the unique best match for `untyped` in a `void`
+                /// context.
+                ast::ptr< ast::Expr > resolveInVoidContext(
+                        const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
+                ) {
+                        assertf( expr, "expected a non-null expression" );
+                        
+                        // set up and resolve expression cast to void
+                        ast::CastExpr * untyped = new ast::CastExpr{ expr->location, expr };
+                        CandidateRef choice = findUnfinishedKindExpression( 
+                                untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
+                        
+                        // a cast expression has either 0 or 1 interpretations (by language rules);
+                        // if 0, an exception has already been thrown, and this code will not run
+                        const ast::CastExpr * castExpr = choice->expr.strict_as< ast::CastExpr >();
+                        env = std::move( choice->env );
+
+                        return castExpr->arg;
+                }
+
+                /// Resolve `untyped` to the expression whose candidate is the best match for a `void` 
+                /// context.
+                ast::ptr< ast::Expr > findVoidExpression( 
+                        const ast::Expr * untyped, const ast::SymbolTable & symtab
+                ) {
+                        resetTyVarRenaming();
+                        ast::TypeEnvironment env;
+                        ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
+                        finishExpr( newExpr, env, untyped->env );
+                        return newExpr;
+                }
+
                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the 
                 /// lowest cost, returning the resolved version
                 ast::ptr< ast::Expr > findKindExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind, 
-                        std::function<bool(const Candidate &)> pred, ResolvMode mode = {}
+                        const ast::Expr * untyped, const ast::SymbolTable & symtab, 
+                        std::function<bool(const Candidate &)> pred = anyCandidate, 
+                        const std::string & kind = "", ResolvMode mode = {}
                 ) {
                         if ( ! untyped ) return {};
@@ -1093 +1140 @@
                         finishExpr( choice->expr, choice->env, untyped->env );
                         return std::move( choice->expr );
+                }
+
+                /// Resolve `untyped` to the single expression whose candidate is the best match for the 
+                /// given type.
+                ast::ptr< ast::Expr > findSingleExpression(
+                        const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
+                ) {
+                        assert( untyped && type );
+                        const ast::Expr * castExpr = new ast::CastExpr{ untyped->location, untyped, type };
+                        ast::ptr< ast::Expr > newExpr = findKindExpression( castExpr, symtab );
+                        removeExtraneousCast( newExpr, symtab );
+                        return newExpr;
                 }
 
@@ -1114 +1173 @@
                         const ast::Expr * untyped, const ast::SymbolTable & symtab 
                 ) {
-                        return findKindExpression( untyped, symtab, "condition", hasIntegralType );
-                }
-        }
-
-        class Resolver_new final 
-        : public ast::WithSymbolTable, public ast::WithGuards, 
-          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting, 
+                        return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
+                }
+        }
+
+        class Resolver_new final
+        : public ast::WithSymbolTable, public ast::WithGuards,
+          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
           public ast::WithStmtsToAdd<> {
-        
+
                 ast::ptr< ast::Type > functionReturn = nullptr;
-                // ast::CurrentObject currentObject = nullptr;
+                ast::CurrentObject currentObject;
                 bool inEnumDecl = false;
 
-        public: 
+        public:
                 Resolver_new() = default;
                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
@@ -1140 +1199 @@
                 void previsit( const ast::PointerType * );
 
-                void previsit( const ast::ExprStmt * );
-                void previsit( const ast::AsmExpr * );
-                void previsit( const ast::AsmStmt * );
-                void previsit( const ast::IfStmt * );
-                void previsit( const ast::WhileStmt * );
-                void previsit( const ast::ForStmt * );
-                void previsit( const ast::SwitchStmt * );
-                void previsit( const ast::CaseStmt * );
-                void previsit( const ast::BranchStmt * );
-                void previsit( const ast::ReturnStmt * );
-                void previsit( const ast::ThrowStmt * );
-                void previsit( const ast::CatchStmt * );
+                const ast::ExprStmt *   previsit( const ast::ExprStmt * );
+                const ast::AsmExpr *    previsit( const ast::AsmExpr * );
+                const ast::AsmStmt *    previsit( const ast::AsmStmt * );
+                const ast::IfStmt *     previsit( const ast::IfStmt * );
+                const ast::WhileStmt *  previsit( const ast::WhileStmt * );
+                const ast::ForStmt *    previsit( const ast::ForStmt * );
+                const ast::SwitchStmt * previsit( const ast::SwitchStmt * );
+                const ast::CaseStmt *   previsit( const ast::CaseStmt * );
+                const ast::BranchStmt * previsit( const ast::BranchStmt * );
+                const ast::ReturnStmt * previsit( const ast::ReturnStmt * );
+                const ast::ThrowStmt *  previsit( const ast::ThrowStmt * );
+                const ast::CatchStmt *  previsit( const ast::CatchStmt * );
                 void previsit( const ast::WaitForStmt * );
 
@@ -1170 +1229 @@
 
         const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 ast::ptr< ast::FunctionDecl > ret = functionDecl;
                 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
                         const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
-                        
+
                         if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
                                 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
                                         if ( init->value->env == nullptr ) continue;
                                         // clone initializer minus the initializer environment
-                                        strict_dynamic_cast< ast::SingleInit * >(
-                                                strict_dynamic_cast< ast::ObjectDecl * >( 
-                                                        ret.get_and_mutate()->type.get_and_mutate()->params[i].get_and_mutate()
-                                                )->init.get_and_mutate()
-                                        )->value.get_and_mutate()->env = nullptr;
+                                        ast::chain_mutate( ret )
+                                                ( &ast::FunctionDecl::type )
+                                                        ( &ast::FunctionType::params )[i]
+                                                                ( &ast::ObjectDecl::init )
+                                                                        ( &ast::SingleInit::value )->env = nullptr;
+
+                                        assert( functionDecl != ret.get() || functionDecl->unique() );
+                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
                                 }
                         }
@@ -1192 +1254 @@
 
         void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)objectDecl;
-                assert(false);
+                // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()], 
+                // class-variable `initContext` is changed multiple times because the LHS is analyzed 
+                // twice. The second analysis changes `initContext` because a function type can contain 
+                // object declarations in the return and parameter types. Therefore each value of 
+                // `initContext` is retained so the type on the first analysis is preserved and used for 
+                // selecting the RHS.
+                GuardValue( currentObject );
+                currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
+                if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since the 
+                        // enum type is still incomplete at this point. Use `int` instead.
+                        currentObject = ast::CurrentObject{ 
+                                objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
+                }
         }
 
@@ -1206 +1279 @@
                 const ast::StaticAssertDecl * assertDecl 
         ) {
-                ast::ptr< ast::Expr > cond = findIntegralExpression( assertDecl->cond, symtab );
-                if ( cond == assertDecl->cond ) return assertDecl;
+                return ast::mutate_field( 
+                        assertDecl, &ast::StaticAssertDecl::cond, 
+                        findIntegralExpression( assertDecl->cond, symtab ) );
+        }
+
+        template< typename PtrType >
+        void handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
+                #warning unimplemented; needs support for new Validate::SizeType global
+                (void)type; (void)symtab;
+                assert( false );
+        }
+
+        void Resolver_new::previsit( const ast::ArrayType * at ) {
+                handlePtrType( at, symtab );
+        }
+
+        void Resolver_new::previsit( const ast::PointerType * pt ) {
+                handlePtrType( pt, symtab );
+        }
+
+        const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
+                visit_children = false;
+                assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
                 
-                ast::StaticAssertDecl * ret = mutate( assertDecl );
-                ret->cond = cond;
-                return ret;
-        }
-
-        void Resolver_new::previsit( const ast::ArrayType * at ) {
-                #warning unimplemented; Resolver port in progress
-                (void)at;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::PointerType * pt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)pt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)exprStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
-                #warning unimplemented; Resolver port in progress
-                (void)asmExpr;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)asmStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)ifStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)whileStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ForStmt * forStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)forStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)switchStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)caseStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)branchStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)returnStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)throwStmt;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)catchStmt;
-                assert(false);
+                return ast::mutate_field( 
+                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
+        }
+
+        const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
+                visit_children = false;
+
+                asmExpr = ast::mutate_field( 
+                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
+                
+                if ( asmExpr->inout ) {
+                        asmExpr = ast::mutate_field(
+                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
+                }
+                
+                return asmExpr;
+        }
+
+        const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
+                visitor->maybe_accept( asmStmt, &ast::AsmStmt::input );
+                visitor->maybe_accept( asmStmt, &ast::AsmStmt::output );
+                visit_children = false;
+                return asmStmt;
+        }
+
+        const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
+                return ast::mutate_field(
+                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
+        }
+
+        const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
+                return ast::mutate_field( 
+                        whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
+        }
+
+        const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) {
+                if ( forStmt->cond ) {
+                        forStmt = ast::mutate_field(
+                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
+                }
+
+                if ( forStmt->inc ) {
+                        forStmt = ast::mutate_field(
+                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
+                }
+
+                return forStmt;
+        }
+
+        const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
+                GuardValue( currentObject );
+                switchStmt = ast::mutate_field(
+                        switchStmt, &ast::SwitchStmt::cond, 
+                        findIntegralExpression( switchStmt->cond, symtab ) );
+                currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
+                return switchStmt;
+        }
+
+        const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
+                if ( caseStmt->cond ) {
+                        std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
+                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
+                                "expression." );
+                        
+                        const ast::Expr * untyped = 
+                                new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
+                        ast::ptr< ast::Expr > newExpr = findKindExpression( untyped, symtab );
+                        
+                        // case condition cannot have a cast in C, so it must be removed here, regardless of 
+                        // whether it would perform a conversion.
+                        if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
+                                ast::ptr< ast::TypeSubstitution > env = castExpr->env;
+                                newExpr.set_and_mutate( castExpr->arg )->env = env;
+                        }
+                        
+                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
+                }
+                return caseStmt;
+        }
+
+        const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
+                visit_children = false;
+                // must resolve the argument of a computed goto
+                if ( branchStmt->kind == ast::BranchStmt::Goto && branchStmt->computedTarget ) {
+                        // computed goto argument is void*
+                        branchStmt = ast::mutate_field(
+                                branchStmt, &ast::BranchStmt::computedTarget, 
+                                findSingleExpression( 
+                                        branchStmt->computedTarget, new ast::PointerType{ new ast::VoidType{} }, 
+                                        symtab ) );
+                }
+                return branchStmt;
+        }
+
+        const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
+                visit_children = false;
+                if ( returnStmt->expr ) {
+                        returnStmt = ast::mutate_field(
+                                returnStmt, &ast::ReturnStmt::expr, 
+                                findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
+                }
+                return returnStmt;
+        }
+
+        const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
+                visit_children = false;
+                if ( throwStmt->expr ) {
+                        const ast::StructDecl * exceptionDecl = 
+                                symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                        assert( exceptionDecl );
+                        ast::ptr< ast::Type > exceptType = 
+                                new ast::PointerType{ new ast::StructInstType{ exceptionDecl } };
+                        throwStmt = ast::mutate_field(
+                                throwStmt, &ast::ThrowStmt::expr, 
+                                findSingleExpression( throwStmt->expr, exceptType, symtab ) );
+                }
+                return throwStmt;
+        }
+
+        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+                if ( catchStmt->cond ) {
+                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
+                        catchStmt = ast::mutate_field( 
+                                catchStmt, &ast::CatchStmt::cond, 
+                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
+                }
+                return catchStmt;
         }