Changeset dc58e5d for src/ResolvExpr

Timestamp:

Apr 15, 2024, 12:24:36 PM (3 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

fb2e916

Parents:

af746cc (diff), 7a36848 (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:

Small cleanup

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (4 diffs)
• CandidateFinder.hpp (modified) (1 diff)
• Resolver.cc (modified) (7 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -46 +46 @@
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for move, copy
-#include "Parser/parserutility.h" // for notZeroExpr
 #include "SymTab/Mangler.h"
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
@@ -1514 +1513 @@
         void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( logicalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( logicalExpr->arg1 );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                ast::ptr<ast::Expr> arg2 = notZeroExpr( logicalExpr->arg2 );
+                ast::ptr<ast::Expr> arg2 = createCondExpr( logicalExpr->arg2 );
                 finder2.find( arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
@@ -1545 +1544 @@
         void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
                 // candidates for condition
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( conditionalExpr->arg1 );
                 CandidateFinder finder1( context, tenv );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
@@ -2166 +2165 @@
                 CandidateRef & choice = winners.front();
                 return choice->expr;
-                // return std::move( choice->expr.get() );
+}
+
+const ast::Expr * createCondExpr( const ast::Expr * expr ) {
+        assert( expr );
+        return new ast::CastExpr( expr->location,
+                ast::UntypedExpr::createCall( expr->location,
+                        "?!=?",
+                        {
+                                expr,
+                                new ast::ConstantExpr( expr->location,
+                                        new ast::ZeroType(), "0", std::make_optional( 0ull )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
 }
 

src/ResolvExpr/CandidateFinder.hpp

@@ -72 +72 @@
 const ast::Expr * getValueEnumCall(const ast::Expr * expr,
         const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env );
+/// Wrap an expression to convert the result to a conditional result.
+const ast::Expr * createCondExpr( const ast::Expr * expr );
 
 } // namespace ResolvExpr

src/ResolvExpr/Resolver.cc

@@ -340 +340 @@
         }
 
+        ast::ptr< ast::Expr > findCondExpression(
+                const ast::Expr * untyped, const ResolveContext & context
+        ) {
+                if ( nullptr == untyped ) return untyped;
+                ast::ptr<ast::Expr> condExpr = createCondExpr( untyped );
+                return findIntegralExpression( condExpr, context );
+        }
+
         /// check if a type is a character type
         bool isCharType( const ast::Type * t ) {
@@ -356 +364 @@
                 return it != end;
         }
-}
+} // anonymous namespace
 
 class Resolver final
@@ -729 +737 @@
 const ast::IfStmt * Resolver::previsit( const ast::IfStmt * ifStmt ) {
         return ast::mutate_field(
-                ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
+                ifStmt, &ast::IfStmt::cond, findCondExpression( ifStmt->cond, context ) );
 }
 
 const ast::WhileDoStmt * Resolver::previsit( const ast::WhileDoStmt * whileDoStmt ) {
         return ast::mutate_field(
-                whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
+                whileDoStmt, &ast::WhileDoStmt::cond, findCondExpression( whileDoStmt->cond, context ) );
 }
 
@@ -740 +748 @@
         if ( forStmt->cond ) {
                 forStmt = ast::mutate_field(
-                        forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
+                        forStmt, &ast::ForStmt::cond, findCondExpression( forStmt->cond, context ) );
         }
 
@@ -1075 +1083 @@
 
                 // Resolve the conditions as if it were an IfStmt, statements normally
-                clause2->when_cond = findSingleExpression( clause.when_cond, context );
+                clause2->when_cond = findCondExpression( clause.when_cond, context );
                 clause2->stmt = clause.stmt->accept( *visitor );
 
@@ -1089 +1097 @@
                         new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
                 auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
-                auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
+                auto timeout_cond = findCondExpression( stmt->timeout_cond, context );
                 auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
 
@@ -1102 +1110 @@
         if ( stmt->else_stmt ) {
                 // resolve the condition like IfStmt, stmts normally
-                auto else_cond = findSingleExpression( stmt->else_cond, context );
+                auto else_cond = findCondExpression( stmt->else_cond, context );
                 auto else_stmt = stmt->else_stmt->accept( *visitor );