Changes in src/ResolvExpr/Resolver.cc [954c954:7ff3e522]

File:

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

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
-#include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "InitTweak/GenInit.h"
@@ -966 +965 @@
                 /// Finds deleted expressions in an expression tree
                 struct DeleteFinder_new final : public ast::WithShortCircuiting {
-                        const ast::DeletedExpr * result = nullptr;
+                        const ast::DeletedExpr * delExpr = nullptr;
 
                         void previsit( const ast::DeletedExpr * expr ) {
-                                if ( result ) { visit_children = false; }
-                                else { result = expr; }
+                                if ( delExpr ) { visit_children = false; }
+                                else { delExpr = expr; }
                         }
 
                         void previsit( const ast::Expr * ) {
-                                if ( result ) { visit_children = false; }
+                                if ( delExpr ) { visit_children = false; }
                         }
                 };
@@ -981 +980 @@
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
-                return ast::Pass<DeleteFinder_new>::read( expr );
+                ast::Pass<DeleteFinder_new> finder;
+                expr->accept( finder );
+                return finder.core.delExpr;
         }
 
@@ -1170 +1171 @@
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
-                        Stats::ResolveTime::start( untyped );
-                        auto res = findKindExpression( untyped, symtab );
-                        Stats::ResolveTime::stop();
-                        return res;
+                        return findKindExpression( untyped, symtab );
                 }
         } // anonymous namespace
@@ -1223 +1221 @@
                 template<typename Iter>
                 inline bool nextMutex( Iter & it, const Iter & end ) {
-                        while ( it != end && ! (*it)->is_mutex() ) { ++it; }
+                        while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
                         return it != end;
                 }
@@ -1263 +1261 @@
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
-                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
 
@@ -1496 +1493 @@
 
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have thenPart)
-                // holds, check it. This allows a check for when to decode the mangling.
-                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
-                        assert( ifStmt->thenPart );
-                }
-                // Encode the catchStmt so the condition can see the declaration.
+                // TODO: This will need a fix for the decl/cond scoping problem.
                 if ( catchStmt->cond ) {
-                        ast::CatchStmt * stmt = mutate( catchStmt );
-                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
-                        stmt->cond = nullptr;
-                        return stmt;
-                }
-                return catchStmt;
-        }
-
-        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
-                // Decode the catchStmt so everything is stored properly.
-                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
-                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
-                        assert( ifStmt->cond );
-                        assert( ifStmt->elsePart );
-                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
-                        stmt->cond = ifStmt->cond;
-                        stmt->body = ifStmt->elsePart;
-                        // ifStmt should be implicately deleted here.
-                        return stmt;
+                        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;
@@ -1638 +1615 @@
                                                                 // Check if the argument matches the parameter type in the current
                                                                 // scope
-                                                                // ast::ptr< ast::Type > paramType = (*param)->get_type();
+                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
                                                                 if (
                                                                         ! unify(
-                                                                                arg->expr->result, *param, resultEnv, need, have, open,
+                                                                                arg->expr->result, paramType, resultEnv, need, have, open,
                                                                                 symtab )
                                                                 ) {
@@ -1648 +1625 @@
                                                                         ss << "candidate function not viable: no known conversion "
                                                                                 "from '";
-                                                                        ast::print( ss, *param );
+                                                                        ast::print( ss, (*param)->get_type() );
                                                                         ss << "' to '";
                                                                         ast::print( ss, arg->expr->result );