Changes in src/ResolvExpr/Resolver.cc [36982fc:882ad37]

File:

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

src/ResolvExpr/Resolver.cc

@@ -74 +74 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
+                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -369 +370 @@
                 if ( throwStmt->get_expr() ) {
                         StructDecl * exception_decl =
-                                indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
                         Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
@@ -568 +569 @@
                         findSingleExpression( stmt->orelse.condition, this->indexer );
                         stmt->orelse.statement->accept( *visitor );
+                }
+        }
+
+        bool isStructOrUnion( Type * t ) {
+                t = t->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                for ( Expression *& expr : withStmt->exprs )  {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( expr );
+
+                        // only struct- and union-typed expressions are viable candidates
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( isStructOrUnion( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
+                                expr->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, expr->env );
+                        delete expr;
+                        expr = alt.expr;
+                        alt.expr = nullptr;
                 }
         }