Changeset c8e4d2f8

Timestamp:

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

Author:

Aaron Moss <a3moss@…>

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:

a2a85658, b408364

Parents:

bc92bee

Message:

Start porting CastExpr? resolution

Location:

src

Files:

• ResolvExpr/Candidate.hpp (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (6 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• ResolvExpr/CastCost.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (1 diff)
• ResolvExpr/ResolveTypeof.h (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (1 diff)
• SymTab/Validate.h (modified) (2 diffs)

src/ResolvExpr/Candidate.hpp

@@ -53 +53 @@
         : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {}
 
-        Candidate( const Candidate & o, const ast::Expr * x )
-        : expr( x ), cost( o.cost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ),
+        Candidate( const Candidate & o, const ast::Expr * x, const Cost & addedCost = Cost::zero )
+        : expr( x ), cost( o.cost + addedCost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ),
           need( o.need ) {}
 

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 } );
                         }
                 }

src/ResolvExpr/CandidateFinder.hpp

@@ -27 +27 @@
 /// Data to perform expression resolution
 struct CandidateFinder {
-        CandidateList candidates;                ///< List of candidate resolutions
-        const ast::SymbolTable & symtab;         ///< Symbol table to lookup candidates
-        const ast::TypeEnvironment & env;        ///< Substitutions performed in this resolution
-        ast::ptr< ast::Type > targetType = nullptr;  ///< Target type for resolution
+        CandidateList candidates;          ///< List of candidate resolutions
+        const ast::SymbolTable & symtab;   ///< Symbol table to lookup candidates
+        const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
+        ast::ptr< ast::Type > targetType;  ///< Target type for resolution
 
-        CandidateFinder( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env )
-        : candidates(), symtab( symtab ), env( env ) {}
+        CandidateFinder( 
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, 
+                const ast::Type * tt = nullptr )
+        : candidates(), symtab( symtab ), env( env ), targetType( tt ) {}
 
         /// Fill candidates with feasible resolutions for `expr`

src/ResolvExpr/CastCost.cc

@@ -78 +78 @@
                         });
                 } else {
-                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
+                        #warning cast on castCost artifact of having two functions, remove when port done
+                        PassVisitor<CastCost> converter( 
+                                dest, indexer, env, 
+                                (Cost (*)( Type *, Type *, const SymTab::Indexer &, const TypeEnvironment & ))
+                                        castCost );
                         src->accept( converter );
                         if ( converter.pass.get_cost() == Cost::infinity ) {
@@ -125 +129 @@
                 }
         }
+
+        Cost castCost( 
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
+                const ast::TypeEnvironment & env 
+        ) {
+                #warning unimplmented
+                (void)src; (void)dst; (void)symtab; (void)env;
+                assert(false);
+                return Cost::zero;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ResolveTypeof.cc

@@ -107 +107 @@
                 return newType;
         }
+
+        const ast::Type * resolveTypeof( const ast::Type * type , const ast::SymbolTable & symtab ) {
+                #warning unimplemented
+                (void)type; (void)symtab;
+                assert(false);
+                return nullptr;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ResolveTypeof.h

@@ -20 +20 @@
 class Indexer;
 }  // namespace SymTab
+namespace ast {
+        class Type;
+        class SymbolTable;
+}
 
 namespace ResolvExpr {
         Type *resolveTypeof( Type*, const SymTab::Indexer &indexer );
+        const ast::Type * resolveTypeof( const ast::Type *, const ast::SymbolTable & );
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -78 +78 @@
         // in CastCost.cc
         Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+        Cost castCost( 
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
+                const ast::TypeEnvironment & env );
 
         // in ConversionCost.cc

src/SymTab/Validate.cc

@@ -1367 +1367 @@
                 return addrExpr;
         }
+
+        const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab ) {
+                #warning unimplemented
+                (void)type; (void)symtab;
+                assert(false);
+                return nullptr;
+        }
 } // namespace SymTab
 

src/SymTab/Validate.h

@@ -22 +22 @@
 class Type;
 
+namespace ast {
+        class Type;
+        class SymbolTable;
+}
+
 namespace SymTab {
         class Indexer;
@@ -28 +33 @@
         void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
         void validateType( Type *type, const Indexer *indexer );
+
+        const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab );
 } // namespace SymTab