Changes in src/ResolvExpr/CandidateFinder.cpp [c8e4d2f8:898ae07]

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (10 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -27 +27 @@
 #include "Cost.h"
 #include "ExplodedArg.hpp"
+#include "RenameVars.h"           // for renameTyVars
 #include "Resolver.h"
 #include "ResolveTypeof.h"
@@ -557 +558 @@
 
         /// Generate a cast expression from `arg` to `toType`
-        const ast::Expr * restructureCast( const ast::Expr * arg, const ast::Type * toType, bool isGenerated ) {
-                #warning unimplemented
-                (void)arg; (void)toType; (void)isGenerated;
-                assert(false);
-                return nullptr;
+        const ast::Expr * restructureCast( 
+                ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated 
+        ) {
+                if ( 
+                        arg->result->size() > 1 
+                        && ! toType->isVoid() 
+                        && ! dynamic_cast< const ast::ReferenceType * >( toType ) 
+                ) {
+                        // Argument is a tuple and the target type is neither void nor a reference. Cast each 
+                        // member of the tuple to its corresponding target type, producing the tuple of those 
+                        // cast expressions. If there are more components of the tuple than components in the 
+                        // target type, then excess components do not come out in the result expression (but 
+                        // UniqueExpr ensures that the side effects will still be produced)
+                        if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
+                                // expressions which may contain side effects require a single unique instance of 
+                                // the expression
+                                arg = new ast::UniqueExpr{ arg->location, arg };
+                        }
+                        std::vector< ast::ptr< ast::Expr > > components;
+                        for ( unsigned i = 0; i < toType->size(); ++i ) {
+                                // cast each component
+                                ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
+                                components.emplace_back( 
+                                        restructureCast( idx, toType->getComponent( i ), isGenerated ) );
+                        }
+                        return new ast::TupleExpr{ arg->location, move( components ) };
+                } else {
+                        // handle normally
+                        return new ast::CastExpr{ arg->location, arg, toType, isGenerated };
+                }
+        }
+
+        /// Gets the name from an untyped member expression (must be NameExpr)
+        const std::string & getMemberName( const ast::UntypedMemberExpr * memberExpr ) {
+                if ( memberExpr->member.as< ast::ConstantExpr >() ) {
+                        SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
+                }
+
+                return memberExpr->member.strict_as< ast::NameExpr >()->name;
         }
 
@@ -764 +799 @@
 
                         if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
-                                addAggMembers( structInst, aggrExpr, cand, Cost::safe, "" );
+                                addAggMembers( structInst, aggrExpr, *cand, Cost::safe, "" );
                         } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
-                                addAggMembers( unionInst, aggrExpr, cand, Cost::safe, "" );
+                                addAggMembers( unionInst, aggrExpr, *cand, Cost::safe, "" );
                         }
                 }
@@ -773 +808 @@
                 void addAggMembers( 
                         const ast::ReferenceToType * aggrInst, const ast::Expr * expr, 
-                        const CandidateRef & cand, const Cost & addedCost, const std::string & name 
+                        const Candidate & cand, const Cost & addedCost, const std::string & name 
                 ) {
                         for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
                                 CandidateRef newCand = std::make_shared<Candidate>( 
-                                        *cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
+                                        cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
                                 // add anonymous member interpretations whenever an aggregate value type is seen 
                                 // as a member expression
                                 addAnonConversions( newCand );
                                 candidates.emplace_back( move( newCand ) );
+                        }
+                }
+
+                /// Adds tuple member interpretations
+                void addTupleMembers( 
+                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand, 
+                        const Cost & addedCost, const ast::Expr * member 
+                ) {
+                        if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
+                                // get the value of the constant expression as an int, must be between 0 and the 
+                                // length of the tuple to have meaning
+                                long long val = constantExpr->intValue();
+                                if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
+                                        addCandidate(
+                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val }, 
+                                                addedCost );
+                                }
                         }
                 }
@@ -1000 +1052 @@
                         }
 
-                        // castExpr->result should be replaced with toType
-                        // candidates => matches
-
-                        #warning unimplemented
-                        (void)castExpr;
-                        assert(false);
+                        // select first on argument cost, then conversion cost
+                        CandidateList minArgCost = findMinCost( matches );
+                        promoteCvtCost( minArgCost );
+                        candidates = findMinCost( minArgCost );
                 }
 
@@ -1021 +1071 @@
 
                 void postvisit( const ast::UntypedMemberExpr * memberExpr ) {
-                        #warning unimplemented
-                        (void)memberExpr;
-                        assert(false);
+                        CandidateFinder aggFinder{ symtab, tenv };
+                        aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
+                        for ( CandidateRef & agg : aggFinder.candidates ) {
+                                // it's okay for the aggregate expression to have reference type -- cast it to the 
+                                // base type to treat the aggregate as the referenced value
+                                Cost addedCost = Cost::zero;
+                                agg->expr = referenceToRvalueConversion( agg->expr, addedCost );
+
+                                // find member of the given type
+                                if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
+                                        addAggMembers( 
+                                                structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
+                                } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
+                                        addAggMembers( 
+                                                unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
+                                } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
+                                        addTupleMembers( tupleType, agg->expr, *agg, addedCost, memberExpr->member );
+                                }
+                        }
                 }
 
@@ -1030 +1096 @@
                 }
 
-                void postvisit( const ast::NameExpr * variableExpr ) {
-                        #warning unimplemented
-                        (void)variableExpr;
-                        assert(false);
+                void postvisit( const ast::NameExpr * nameExpr ) {
+                        std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name );
+                        PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
+                        for ( auto & data : declList ) {
+                                Cost cost = Cost::zero;
+                                ast::Expr * newExpr = data.combine( nameExpr->location, cost );
+
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, 
+                                        cost );
+                                PRINT(
+                                        std::cerr << "decl is ";
+                                        ast::print( std::cerr, data.id );
+                                        std::cerr << std::endl;
+                                        std::cerr << "newExpr is ";
+                                        ast::print( std::cerr, newExpr );
+                                        std::cerr << std::endl;
+                                )
+                                newCand->expr = ast::mutate_field( 
+                                        newCand->expr.get(), &ast::Expr::result, 
+                                        renameTyVars( newCand->expr->result ) );
+                                // add anonymous member interpretations whenever an aggregate value type is seen 
+                                // as a name expression
+                                addAnonConversions( newCand );
+                                candidates.emplace_back( move( newCand ) );
+                        }
                 }
 
@@ -1048 +1136 @@
 
                 void postvisit( const ast::SizeofExpr * sizeofExpr ) {
-                        #warning unimplemented
-                        (void)sizeofExpr;
-                        assert(false);
+                        if ( sizeofExpr->type ) {
+                                addCandidate( 
+                                        new ast::SizeofExpr{ 
+                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) }, 
+                                        tenv );
+                        } else {
+                                // find all candidates for the argument to sizeof
+                                CandidateFinder finder{ symtab, tenv };
+                                finder.find( sizeofExpr->expr );
+                                // find the lowest-cost candidate, otherwise ambiguous
+                                CandidateList winners = findMinCost( finder.candidates );
+                                if ( winners.size() != 1 ) {
+                                        SemanticError( 
+                                                sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
+                                }
+                                // return the lowest-cost candidate
+                                CandidateRef & choice = winners.front();
+                                choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                                choice->cost = Cost::zero;
+                                addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
+                        }
                 }
 
                 void postvisit( const ast::AlignofExpr * alignofExpr ) {
-                        #warning unimplemented
-                        (void)alignofExpr;
-                        assert(false);
+                        if ( alignofExpr->type ) {
+                                addCandidate( 
+                                        new ast::AlignofExpr{ 
+                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) }, 
+                                        tenv );
+                        } else {
+                                // find all candidates for the argument to alignof
+                                CandidateFinder finder{ symtab, tenv };
+                                finder.find( alignofExpr->expr );
+                                // find the lowest-cost candidate, otherwise ambiguous
+                                CandidateList winners = findMinCost( finder.candidates );
+                                if ( winners.size() != 1 ) {
+                                        SemanticError( 
+                                                alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
+                                }
+                                // return the lowest-cost candidate
+                                CandidateRef & choice = winners.front();
+                                choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                                choice->cost = Cost::zero;
+                                addCandidate( 
+                                        *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
+                        }
                 }
 
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        #warning unimplemented
-                        (void)offsetofExpr;
-                        assert(false);
+                        const ast::ReferenceToType * aggInst;
+                        if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
+                        else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;
+                        else return;
+
+                        for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
+                                auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
+                                addCandidate( 
+                                        new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
+                        }
                 }
 
@@ -1139 +1271 @@
                                                                 common ) 
                                                 ) {
-                                                        #warning unimplemented
-                                                        assert(false);
+                                                        // generate typed expression
+                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{ 
+                                                                conditionalExpr->location, r1->expr, r2->expr, r3->expr };
+                                                        newExpr->result = common ? common : r2->expr->result;
+                                                        // convert both options to result type
+                                                        Cost cost = r1->cost + r2->cost + r3->cost;
+                                                        newExpr->arg2 = computeExpressionConversionCost( 
+                                                                newExpr->arg2, newExpr->result, symtab, env, cost );
+                                                        newExpr->arg3 = computeExpressionConversionCost(
+                                                                newExpr->arg3, newExpr->result, symtab, env, cost );
+                                                        // output candidate
+                                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                                newExpr, move( env ), move( open ), move( need ), cost );
+                                                        inferParameters( newCand, candidates );
                                                 }
                                         }
@@ -1198 +1342 @@
                                                         common ) 
                                         ) {
+                                                // generate new expression
                                                 ast::RangeExpr * newExpr = 
                                                         new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
                                                 newExpr->result = common ? common : r1->expr->result;
-                                                
-                                                #warning unimplemented
-                                                assert(false);
+                                                // add candidate
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        newExpr, move( env ), move( open ), move( need ), 
+                                                        r1->cost + r2->cost );
+                                                inferParameters( newCand, candidates );
                                         }
                                 }