Changeset c6a1e8a for src/ResolvExpr

Timestamp:

Jun 5, 2019, 8:36:48 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

866545b

Parents:

67130fe (diff), 3cd5fdd (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:

fix conflicit

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• Candidate.cpp (added)
• Candidate.hpp (added)
• CandidateFinder.cpp (added)
• CandidateFinder.hpp (added)
• ResolveAssertions.cc (modified) (2 diffs)
• Resolver.cc (modified) (29 diffs)
• module.mk (modified) (1 diff)
• typeops.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -136 +136 @@
 
         void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
-                Indenter indent = { Indenter::tabsize, indentAmt };
+                Indenter indent = { indentAmt };
                 for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
                         i->print( os, indent );

src/ResolvExpr/ResolveAssertions.cc

@@ -365 +365 @@
                                         // fail early if any assertion is not resolvable
                                         if ( ! resolveAssertion( assn, resn ) ) {
-                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                Indenter tabs{ 3 };
                                                 std::ostringstream ss;
                                                 ss << tabs << "Unsatisfiable alternative:\n";
@@ -391 +391 @@
                                         // fail early if no mutually-compatible assertion satisfaction
                                         if ( compatible.empty() ) {
-                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                Indenter tabs{ 3 };
                                                 std::ostringstream ss;
                                                 ss << tabs << "Unsatisfiable alternative:\n";

src/ResolvExpr/Resolver.cc

@@ -21 +21 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
+#include "Candidate.hpp"
+#include "CandidateFinder.hpp"
 #include "CurrentObject.h"               // for CurrentObject
 #include "RenameVars.h"                  // for RenameVars, global_renamer
@@ -27 +29 @@
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "AST/Chain.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Init.hpp"
 #include "AST/Pass.hpp"
+#include "AST/Print.hpp"
 #include "AST/SymbolTable.hpp"
 #include "Common/PassVisitor.h"          // for PassVisitor
@@ -113 +119 @@
 
         namespace {
-                struct DeleteFinder : public WithShortCircuiting        {
+                struct DeleteFinder_old : public WithShortCircuiting    {
                         DeletedExpr * delExpr = nullptr;
                         void previsit( DeletedExpr * expr ) {
@@ -127 +133 @@
 
         DeletedExpr * findDeletedExpr( Expression * expr ) {
-                PassVisitor<DeleteFinder> finder;
+                PassVisitor<DeleteFinder_old> finder;
                 expr->accept( finder );
                 return finder.pass.delExpr;
@@ -133 +139 @@
 
         namespace {
-                struct StripCasts {
+                struct StripCasts_old {
                         Expression * postmutate( CastExpr * castExpr ) {
                                 if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
@@ -146 +152 @@
 
                         static void strip( Expression *& expr ) {
-                                PassVisitor<StripCasts> stripper;
+                                PassVisitor<StripCasts_old> stripper;
                                 expr = expr->acceptMutator( stripper );
                         }
@@ -154 +160 @@
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
-                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
+                        StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
                 }
 
@@ -405 +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 );
@@ -445 +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
@@ -937 +943 @@
         ///////////////////////////////////////////////////////////////////////////
 
-        class Resolver_new final 
-        : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef<Resolver_new>, 
-          public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> {
-                  
-        public: 
+        namespace {
+                /// Finds deleted expressions in an expression tree
+                struct DeleteFinder_new final : public ast::WithShortCircuiting {
+                        const ast::DeletedExpr * delExpr = nullptr;
+
+                        void previsit( const ast::DeletedExpr * expr ) {
+                                if ( delExpr ) { visit_children = false; }
+                                else { delExpr = expr; }
+                        }
+
+                        void previsit( const ast::Expr * ) {
+                                if ( delExpr ) { visit_children = false; }
+                        }
+                };
+
+                /// Check if this expression is or includes a deleted expression
+                const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
+                        ast::Pass<DeleteFinder_new> finder;
+                        expr->accept( finder );
+                        return finder.pass.delExpr;
+                }
+
+                /// 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 = {}
+                ) {
+                        if ( ! untyped ) return nullptr;
+
+                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
+                        static unsigned recursion_level = 0;
+
+                        ++recursion_level;
+                        ast::TypeEnvironment env;
+                        CandidateFinder finder{ symtab, env };
+                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
+                        --recursion_level;
+
+                        // produce a filtered list of candidates
+                        CandidateList candidates;
+                        for ( auto & cand : finder.candidates ) {
+                                if ( pred( *cand ) ) { candidates.emplace_back( cand ); }
+                        }
+
+                        // produce invalid error if no candidates
+                        if ( candidates.empty() ) {
+                                SemanticError( untyped, 
+                                        toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""), 
+                                        "expression: ") );
+                        }
+
+                        // search for cheapest candidate
+                        CandidateList winners;
+                        bool seen_undeleted = false;
+                        for ( CandidateRef & cand : candidates ) {
+                                int c = winners.empty() ? -1 : cand->cost.compare( winners.front()->cost );
+
+                                if ( c > 0 ) continue;  // skip more expensive than winner
+
+                                if ( c < 0 ) {
+                                        // reset on new cheapest
+                                        seen_undeleted = ! findDeletedExpr( cand->expr );
+                                        winners.clear();
+                                } else /* if ( c == 0 ) */ {
+                                        if ( findDeletedExpr( cand->expr ) ) {
+                                                // skip deleted expression if already seen one equivalent-cost not
+                                                if ( seen_undeleted ) continue;
+                                        } else if ( ! seen_undeleted ) {
+                                                // replace list of equivalent-cost deleted expressions with one non-deleted
+                                                winners.clear();
+                                                seen_undeleted = true;
+                                        }
+                                }
+
+                                winners.emplace_back( std::move( cand ) );
+                        }
+
+                        // promote candidate.cvtCost to .cost
+                        for ( CandidateRef & cand : winners ) {
+                                cand->cost = cand->cvtCost;
+                        }
+
+                        // produce ambiguous errors, if applicable
+                        if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " 
+                                        << kind << (kind != "" ? " " : "") << "expression\n";
+                                ast::print( stream, untyped );
+                                stream << " Alternatives are:\n";
+                                print( stream, winners, 1 );
+                                SemanticError( untyped->location, stream.str() );
+                        }
+
+                        // single selected choice
+                        CandidateRef & choice = winners.front();
+
+                        // fail on only expression deleted
+                        if ( ! seen_undeleted ) {
+                                SemanticError( untyped->location, choice->expr.get(), "Unique best alternative "
+                                "includes deleted identifier in " );
+                        }
+
+                        return std::move( choice );
+                }
+
+                /// Strips extraneous casts out of an expression
+                struct StripCasts_new final {
+                        const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
+                                if ( 
+                                        castExpr->isGenerated 
+                                        && typesCompatible( castExpr->arg->result, castExpr->result ) 
+                                ) {
+                                        // 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 castExpr;
+                        }
+
+                        static void strip( ast::ptr< ast::Expr > & expr ) {
+                                ast::Pass< StripCasts_new > stripper;
+                                expr = expr->accept( stripper );
+                        }
+                };
+
+                /// Establish post-resolver invariants for expressions
+                void finishExpr( 
+                        ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env, 
+                        const ast::TypeSubstitution * oldenv = nullptr
+                ) {
+                        // set up new type substitution for expression
+                        ast::ptr< ast::TypeSubstitution > newenv = 
+                                 oldenv ? oldenv : new ast::TypeSubstitution{};
+                        env.writeToSubstitution( *newenv.get_and_mutate() );
+                        expr.get_and_mutate()->env = std::move( newenv );
+                        // remove unncecessary casts
+                        StripCasts_new::strip( expr );
+                }
+                
+                /// 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 = {}
+                ) {
+                        if ( ! untyped ) return {};
+                        CandidateRef choice = 
+                                findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
+                        finishExpr( choice->expr, choice->env, untyped->env );
+                        return std::move( choice->expr );
+                }
+
+                /// Predicate for "Candidate has integral type"
+                bool hasIntegralType( const Candidate & i ) {
+                        const ast::Type * type = i.expr->result;
+                        
+                        if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
+                                return bt->isInteger();
+                        } else if ( 
+                                dynamic_cast< const ast::EnumInstType * >( type ) 
+                                || dynamic_cast< const ast::ZeroType * >( type )
+                                || dynamic_cast< const ast::OneType * >( type )
+                        ) {
+                                return true;
+                        } else return false;
+                }
+
+                /// Resolve `untyped` as an integral expression, returning the resolved version
+                ast::ptr< ast::Expr > findIntegralExpression( 
+                        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,
+          public ast::WithStmtsToAdd<> {
+
+                ast::ptr< ast::Type > functionReturn = nullptr;
+                // ast::CurrentObject currentObject = nullptr;
+                bool inEnumDecl = false;
+
+        public:
                 Resolver_new() = default;
-                Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ }
-
-                void previsit( ast::FunctionDecl * functionDecl );
-                ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl );
-                void previsit( ast::ObjectDecl * objectDecl );
-                void previsit( ast::EnumDecl * enumDecl );
-                void previsit( ast::StaticAssertDecl * assertDecl );
-
-                void previsit( ast::ArrayType * at );
-                void previsit( ast::PointerType * pt );
-
-                void previsit( ast::ExprStmt * exprStmt );
-                void previsit( ast::AsmExpr * asmExpr );
-                void previsit( ast::AsmStmt * asmStmt );
-                void previsit( ast::IfStmt * ifStmt );
-                void previsit( ast::WhileStmt * whileStmt );
-                void previsit( ast::ForStmt * forStmt );
-                void previsit( ast::SwitchStmt * switchStmt );
-                void previsit( ast::CaseStmt * caseStmt );
-                void previsit( ast::BranchStmt * branchStmt );
-                void previsit( ast::ReturnStmt * returnStmt );
-                void previsit( ast::ThrowStmt * throwStmt );
-                void previsit( ast::CatchStmt * catchStmt );
-                void previsit( ast::WaitForStmt * stmt );
-
-                void previsit( ast::SingleInit * singleInit );
-                void previsit( ast::ListInit * listInit );
-                void previsit( ast::ConstructorInit * ctorInit );
+                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
+
+                void previsit( const ast::FunctionDecl * );
+                const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
+                void previsit( const ast::ObjectDecl * );
+                void previsit( const ast::EnumDecl * );
+                const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
+
+                void previsit( const ast::ArrayType * );
+                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 * );
+                void previsit( const ast::WaitForStmt * );
+
+                void previsit( const ast::SingleInit * );
+                void previsit( const ast::ListInit * );
+                void previsit( const ast::ConstructorInit * );
         };
 
@@ -978 +1165 @@
         }
 
-        void previsit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-        }
-
-        ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-                return nullptr;
-        }
-
-        void previsit( ast::ObjectDecl * objectDecl ) {
+        void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
+                GuardValue( functionReturn );
+                functionReturn = extractResultType( functionDecl->type );
+        }
+
+        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
+                // 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
+                                        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 );
+                                }
+                        }
+                }
+                return ret.get();
+        }
+
+        void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
                 #warning unimplemented; Resolver port in progress
                 (void)objectDecl;
@@ -997 +1201 @@
         }
 
-        void previsit( ast::EnumDecl * enumDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)enumDecl;
-                assert(false);
-        }
-
-        void previsit( ast::StaticAssertDecl * assertDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)assertDecl;
-                assert(false);
-        }
-
-        void previsit( ast::ArrayType * at ) {
+        void Resolver_new::previsit( const ast::EnumDecl * ) {
+                // in case we decide to allow nested enums
+                GuardValue( inEnumDecl );
+                inEnumDecl = false;
+        }
+
+        const ast::StaticAssertDecl * Resolver_new::previsit( 
+                const ast::StaticAssertDecl * assertDecl 
+        ) {
+                ast::ptr< ast::Expr > cond = findIntegralExpression( assertDecl->cond, symtab );
+                if ( cond == assertDecl->cond ) return assertDecl;
+                
+                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;
@@ -1015 +1224 @@
         }
 
-        void previsit( ast::PointerType * pt ) {
+        void Resolver_new::previsit( const ast::PointerType * pt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)pt;
@@ -1021 +1230 @@
         }
 
-        void previsit( ast::ExprStmt * exprStmt ) {
+        void Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)exprStmt;
@@ -1027 +1236 @@
         }
 
-        void previsit( ast::AsmExpr * asmExpr ) {
+        void Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
                 #warning unimplemented; Resolver port in progress
                 (void)asmExpr;
@@ -1033 +1242 @@
         }
 
-        void previsit( ast::AsmStmt * asmStmt ) {
+        void Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)asmStmt;
@@ -1039 +1248 @@
         }
 
-        void previsit( ast::IfStmt * ifStmt ) {
+        void Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)ifStmt;
@@ -1045 +1254 @@
         }
 
-        void previsit( ast::WhileStmt * whileStmt ) {
+        void Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)whileStmt;
@@ -1051 +1260 @@
         }
 
-        void previsit( ast::ForStmt * forStmt ) {
+        void Resolver_new::previsit( const ast::ForStmt * forStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)forStmt;
@@ -1057 +1266 @@
         }
 
-        void previsit( ast::SwitchStmt * switchStmt ) {
+        void Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)switchStmt;
@@ -1063 +1272 @@
         }
 
-        void previsit( ast::CaseStmt * caseStmt ) {
+        void Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)caseStmt;
@@ -1069 +1278 @@
         }
 
-        void previsit( ast::BranchStmt * branchStmt ) {
+        void Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)branchStmt;
@@ -1075 +1284 @@
         }
 
-        void previsit( ast::ReturnStmt * returnStmt ) {
+        void Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)returnStmt;
@@ -1081 +1290 @@
         }
 
-        void previsit( ast::ThrowStmt * throwStmt ) {
+        void Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)throwStmt;
@@ -1087 +1296 @@
         }
 
-        void previsit( ast::CatchStmt * catchStmt ) {
+        void Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)catchStmt;
@@ -1093 +1302 @@
         }
 
-        void previsit( ast::WaitForStmt * stmt ) {
+        void Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
                 #warning unimplemented; Resolver port in progress
                 (void)stmt;
@@ -1099 +1308 @@
         }
 
-        void previsit( ast::SingleInit * singleInit ) {
+        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)singleInit;
@@ -1105 +1314 @@
         }
 
-        void previsit( ast::ListInit * listInit ) {
+        void Resolver_new::previsit( const ast::ListInit * listInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)listInit;
@@ -1111 +1320 @@
         }
 
-        void previsit( ast::ConstructorInit * ctorInit ) {
+        void Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
                 #warning unimplemented; Resolver port in progress
                 (void)ctorInit;

src/ResolvExpr/module.mk

@@ -19 +19 @@
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/Candidate.cpp \
+      ResolvExpr/CandidateFinder.cpp \
       ResolvExpr/CastCost.cc \
       ResolvExpr/CommonType.cc \

src/ResolvExpr/typeops.h

@@ -103 +103 @@
 
         bool typesCompatible( 
-                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
+                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {}, 
                 const ast::TypeEnvironment & env = {} );