Changeset c8e4d2f8 for src/ResolvExpr/CandidateFinder.cpp

Timestamp:

Jun 18, 2019, 11:47:44 AM (4 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

a2a85658, b408364

Parents:

bc92bee

Message:

Start porting CastExpr? resolution

File:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -28 +28 @@
 #include "ExplodedArg.hpp"
 #include "Resolver.h"
+#include "ResolveTypeof.h"
 #include "SatisfyAssertions.hpp"
 #include "typeops.h"              // for adjustExprType, conversionCost, polyCost, specCost
@@ -38 +39 @@
 #include "AST/Type.hpp"
 #include "SymTab/Mangler.h"
+#include "SymTab/Validate.h"      // for validateType
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
 
@@ -554 +556 @@
         }
 
+        /// 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;
+        }
+
         /// Actually visits expressions to find their candidate interpretations
         struct Finder final : public ast::WithShortCircuiting {
@@ -741 +751 @@
                 /// Adds implicit struct-conversions to the alternative list
                 void addAnonConversions( const CandidateRef & cand ) {
-                        #warning unimplemented
-                        (void)cand;
-                        assert(false);
+                        // adds anonymous member interpretations whenever an aggregate value type is seen. 
+                        // 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
+                        ast::ptr< ast::Expr > aggrExpr( cand->expr );
+                        ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
+                        cand->env.apply( aggrType );
+                        
+                        if ( aggrType.as< ast::ReferenceType >() ) {
+                                aggrExpr = 
+                                        new ast::CastExpr{ aggrExpr->location, aggrExpr, aggrType->stripReferences() };
+                        }
+
+                        if ( auto structInst = aggrExpr->result.as< ast::StructInstType >() ) {
+                                addAggMembers( structInst, aggrExpr, cand, Cost::safe, "" );
+                        } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
+                                addAggMembers( unionInst, aggrExpr, cand, Cost::safe, "" );
+                        }
+                }
+
+                /// Adds aggregate member interpretations
+                void addAggMembers( 
+                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr, 
+                        const CandidateRef & 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 );
+                                // add anonymous member interpretations whenever an aggregate value type is seen 
+                                // as a member expression
+                                addAnonConversions( newCand );
+                                candidates.emplace_back( move( newCand ) );
+                        }
                 }
 
@@ -915 +955 @@
 
                 void postvisit( const ast::CastExpr * castExpr ) {
+                        ast::ptr< ast::Type > toType = castExpr->result;
+                        assert( toType );
+                        toType = resolveTypeof( toType, symtab );
+                        toType = SymTab::validateType( toType, symtab );
+                        toType = adjustExprType( toType, tenv, symtab );
+
+                        CandidateFinder finder{ symtab, tenv, toType };
+                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+
+                        CandidateList matches;
+                        for ( CandidateRef & cand : finder.candidates ) {
+                                ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
+                                ast::OpenVarSet open( cand->open );
+
+                                cand->env.extractOpenVars( open );
+
+                                // It is possible that a cast can throw away some values in a multiply-valued 
+                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the 
+                                // subexpression results that are cast directly. The candidate is invalid if it 
+                                // has fewer results than there are types to cast to.
+                                int discardedValues = cand->expr->result->size() - toType->size();
+                                if ( discardedValues < 0 ) continue;
+
+                                // unification run for side-effects
+                                unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
+                                Cost thisCost = castCost( cand->expr->result, toType, symtab, cand->env );
+                                PRINT(
+                                        std::cerr << "working on cast with result: " << toType << std::endl;
+                                        std::cerr << "and expr type: " << cand->expr->result << std::endl;
+                                        std::cerr << "env: " << cand->env << std::endl;
+                                )
+                                if ( thisCost != Cost::infinity ) {
+                                        PRINT(
+                                                std::cerr << "has finite cost." << std::endl;
+                                        )
+                                        // count one safe conversion for each value that is thrown away
+                                        thisCost.incSafe( discardedValues );
+                                        CandidateRef newCand = std::make_shared<Candidate>( 
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ), 
+                                                copy( cand->env ), move( open ), move( need ), cand->cost, 
+                                                cand->cost + thisCost );
+                                        inferParameters( newCand, matches );
+                                }
+                        }
+
+                        // castExpr->result should be replaced with toType
+                        // candidates => matches
+
                         #warning unimplemented
                         (void)castExpr;
@@ -927 +1015 @@
                         for ( CandidateRef & r : finder.candidates ) {
                                 addCandidate( 
-                                        *r, new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
+                                        *r, 
+                                        new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
                         }
                 }