Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/AlternativeFinder.cc (revision d76c588058daa6269114595a571223a110ced0ab) @@ -28,4 +28,6 @@ #include "Alternative.h" // for AltList, Alternative #include "AlternativeFinder.h" +#include "AST/Expr.hpp" +#include "AST/Type.hpp" #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for deleteAll, printAll, CodeLocation @@ -222,4 +224,14 @@ cost.incReference(); } + } + + const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ) { + if ( expr->result.as< ast::ReferenceType >() ) { + // cast away reference from expr + cost.incReference(); + return new ast::CastExpr{ expr->location, expr, expr->result->stripReferences() }; + } + + return expr; } Index: src/ResolvExpr/ResolveAssertions.cc =================================================================== --- src/ResolvExpr/ResolveAssertions.cc (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/ResolveAssertions.cc (revision d76c588058daa6269114595a571223a110ced0ab) @@ -30,4 +30,5 @@ #include "Common/Indenter.h" // for Indenter #include "Common/utility.h" // for sort_mins +#include "GenPoly/GenPoly.h" // for getFunctionType #include "ResolvExpr/RenameVars.h" // for renameTyVars #include "SymTab/Indexer.h" // for Indexer @@ -154,15 +155,10 @@ Cost k = Cost::zero; for ( const auto& assn : x.assns ) { + // compute conversion cost from satisfying decl to assertion k += computeConversionCost( assn.match.adjType, assn.decl->get_type(), indexer, x.env ); // mark vars+specialization cost on function-type assertions - Type* assnType = assn.match.cdata.id->get_type(); - FunctionType* func; - if ( PointerType* ptr = dynamic_cast< PointerType* >( assnType ) ) { - func = dynamic_cast< FunctionType* >( ptr->base ); - } else { - func = dynamic_cast< FunctionType* >( assnType ); - } + FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() ); if ( ! func ) continue; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/Resolver.cc (revision d76c588058daa6269114595a571223a110ced0ab) @@ -7,9 +7,9 @@ // Resolver.cc -- // -// Author : Richard C. Bilson +// Author : Aaron B. Moss // Created On : Sun May 17 12:17:01 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Tue Feb 19 18:09:56 2019 -// Update Count : 240 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed May 29 11:00:00 2019 +// Update Count : 241 // @@ -21,14 +21,18 @@ #include "Alternative.h" // for Alternative, AltList #include "AlternativeFinder.h" // for AlternativeFinder, resolveIn... +#include "CurrentObject.h" // for CurrentObject +#include "RenameVars.h" // for RenameVars, global_renamer +#include "Resolver.h" +#include "ResolvMode.h" // for ResolvMode +#include "typeops.h" // for extractResultType +#include "Unify.h" // for unify +#include "AST/Pass.hpp" +#include "AST/SymbolTable.hpp" #include "Common/PassVisitor.h" // for PassVisitor #include "Common/SemanticError.h" // for SemanticError #include "Common/utility.h" // for ValueGuard, group_iterate -#include "CurrentObject.h" // for CurrentObject #include "InitTweak/GenInit.h" #include "InitTweak/InitTweak.h" // for isIntrinsicSingleArgCallStmt -#include "RenameVars.h" // for RenameVars, global_renamer #include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment -#include "Resolver.h" -#include "ResolvMode.h" // for ResolvMode #include "SymTab/Autogen.h" // for SizeType #include "SymTab/Indexer.h" // for Indexer @@ -41,13 +45,11 @@ #include "SynTree/Visitor.h" // for acceptAll, maybeAccept #include "Tuples/Tuples.h" -#include "typeops.h" // for extractResultType -#include "Unify.h" // for unify using namespace std; namespace ResolvExpr { - struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef, public WithShortCircuiting, public WithStmtsToAdd { - Resolver() {} - Resolver( const SymTab::Indexer & other ) { + struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef, public WithShortCircuiting, public WithStmtsToAdd { + Resolver_old() {} + Resolver_old( const SymTab::Indexer & other ) { indexer = other; } @@ -100,10 +102,10 @@ void resolve( std::list< Declaration * > translationUnit ) { - PassVisitor resolver; + PassVisitor resolver; acceptAll( translationUnit, resolver ); } void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) { - PassVisitor resolver( indexer ); + PassVisitor resolver( indexer ); maybeAccept( decl, resolver ); } @@ -401,5 +403,5 @@ } - void Resolver::previsit( ObjectDecl * objectDecl ) { + void Resolver_old::previsit( ObjectDecl * objectDecl ) { // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that // class-variable initContext is changed multiple time because the LHS is analysed twice. @@ -417,5 +419,5 @@ template< typename PtrType > - void Resolver::handlePtrType( PtrType * type ) { + void Resolver_old::handlePtrType( PtrType * type ) { if ( type->get_dimension() ) { findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer ); @@ -423,13 +425,13 @@ } - void Resolver::previsit( ArrayType * at ) { + void Resolver_old::previsit( ArrayType * at ) { handlePtrType( at ); } - void Resolver::previsit( PointerType * pt ) { + void Resolver_old::previsit( PointerType * pt ) { handlePtrType( pt ); } - void Resolver::previsit( FunctionDecl * functionDecl ) { + void Resolver_old::previsit( FunctionDecl * functionDecl ) { #if 0 std::cerr << "resolver visiting functiondecl "; @@ -441,5 +443,5 @@ } - void Resolver::postvisit( FunctionDecl * functionDecl ) { + void Resolver_old::postvisit( FunctionDecl * functionDecl ) { // default value expressions have an environment which shouldn't be there and trips up // later passes. @@ -456,5 +458,5 @@ } - void Resolver::previsit( EnumDecl * ) { + void Resolver_old::previsit( EnumDecl * ) { // in case we decide to allow nested enums GuardValue( inEnumDecl ); @@ -462,9 +464,9 @@ } - void Resolver::previsit( StaticAssertDecl * assertDecl ) { + void Resolver_old::previsit( StaticAssertDecl * assertDecl ) { findIntegralExpression( assertDecl->condition, indexer ); } - void Resolver::previsit( ExprStmt * exprStmt ) { + void Resolver_old::previsit( ExprStmt * exprStmt ) { visit_children = false; assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" ); @@ -472,5 +474,5 @@ } - void Resolver::previsit( AsmExpr * asmExpr ) { + void Resolver_old::previsit( AsmExpr * asmExpr ) { visit_children = false; findVoidExpression( asmExpr->operand, indexer ); @@ -480,5 +482,5 @@ } - void Resolver::previsit( AsmStmt * asmStmt ) { + void Resolver_old::previsit( AsmStmt * asmStmt ) { visit_children = false; acceptAll( asmStmt->get_input(), *visitor ); @@ -486,13 +488,13 @@ } - void Resolver::previsit( IfStmt * ifStmt ) { + void Resolver_old::previsit( IfStmt * ifStmt ) { findIntegralExpression( ifStmt->condition, indexer ); } - void Resolver::previsit( WhileStmt * whileStmt ) { + void Resolver_old::previsit( WhileStmt * whileStmt ) { findIntegralExpression( whileStmt->condition, indexer ); } - void Resolver::previsit( ForStmt * forStmt ) { + void Resolver_old::previsit( ForStmt * forStmt ) { if ( forStmt->condition ) { findIntegralExpression( forStmt->condition, indexer ); @@ -504,5 +506,5 @@ } - void Resolver::previsit( SwitchStmt * switchStmt ) { + void Resolver_old::previsit( SwitchStmt * switchStmt ) { GuardValue( currentObject ); findIntegralExpression( switchStmt->condition, indexer ); @@ -511,5 +513,5 @@ } - void Resolver::previsit( CaseStmt * caseStmt ) { + void Resolver_old::previsit( CaseStmt * caseStmt ) { if ( caseStmt->condition ) { std::list< InitAlternative > initAlts = currentObject.getOptions(); @@ -530,5 +532,5 @@ } - void Resolver::previsit( BranchStmt * branchStmt ) { + void Resolver_old::previsit( BranchStmt * branchStmt ) { visit_children = false; // must resolve the argument for a computed goto @@ -541,5 +543,5 @@ } - void Resolver::previsit( ReturnStmt * returnStmt ) { + void Resolver_old::previsit( ReturnStmt * returnStmt ) { visit_children = false; if ( returnStmt->expr ) { @@ -548,5 +550,5 @@ } - void Resolver::previsit( ThrowStmt * throwStmt ) { + void Resolver_old::previsit( ThrowStmt * throwStmt ) { visit_children = false; // TODO: Replace *exception type with &exception type. @@ -560,5 +562,5 @@ } - void Resolver::previsit( CatchStmt * catchStmt ) { + void Resolver_old::previsit( CatchStmt * catchStmt ) { if ( catchStmt->cond ) { findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer ); @@ -575,5 +577,5 @@ } - void Resolver::previsit( WaitForStmt * stmt ) { + void Resolver_old::previsit( WaitForStmt * stmt ) { visit_children = false; @@ -781,5 +783,5 @@ } - void Resolver::previsit( SingleInit * singleInit ) { + void Resolver_old::previsit( SingleInit * singleInit ) { visit_children = false; // resolve initialization using the possibilities as determined by the currentObject cursor @@ -833,5 +835,5 @@ } - void Resolver::previsit( ListInit * listInit ) { + void Resolver_old::previsit( ListInit * listInit ) { visit_children = false; // move cursor into brace-enclosed initializer-list @@ -868,5 +870,5 @@ // ConstructorInit - fall back on C-style initializer - void Resolver::fallbackInit( ConstructorInit * ctorInit ) { + void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) { // could not find valid constructor, or found an intrinsic constructor // fall back on C-style initializer @@ -881,5 +883,5 @@ void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) { assert( ctorInit ); - PassVisitor resolver( indexer ); + PassVisitor resolver( indexer ); ctorInit->accept( resolver ); } @@ -887,5 +889,5 @@ void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) { assert( stmtExpr ); - PassVisitor resolver( indexer ); + PassVisitor resolver( indexer ); stmtExpr->accept( resolver ); stmtExpr->computeResult(); @@ -893,5 +895,5 @@ } - void Resolver::previsit( ConstructorInit * ctorInit ) { + void Resolver_old::previsit( ConstructorInit * ctorInit ) { visit_children = false; // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit @@ -927,4 +929,191 @@ // } } + + /////////////////////////////////////////////////////////////////////////// + // + // *** NEW RESOLVER *** + // + /////////////////////////////////////////////////////////////////////////// + + class Resolver_new final + : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef, + public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> { + + public: + Resolver_new() = default; + Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ } + + void previsit( ast::FunctionDecl * functionDecl ); + ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ); + void previsit( ast::ObjectDecl * objectDecl ); + void previsit( ast::EnumDecl * enumDecl ); + void previsit( ast::StaticAssertDecl * assertDecl ); + + void previsit( ast::ArrayType * at ); + void previsit( ast::PointerType * pt ); + + void previsit( ast::ExprStmt * exprStmt ); + void previsit( ast::AsmExpr * asmExpr ); + void previsit( ast::AsmStmt * asmStmt ); + void previsit( ast::IfStmt * ifStmt ); + void previsit( ast::WhileStmt * whileStmt ); + void previsit( ast::ForStmt * forStmt ); + void previsit( ast::SwitchStmt * switchStmt ); + void previsit( ast::CaseStmt * caseStmt ); + void previsit( ast::BranchStmt * branchStmt ); + void previsit( ast::ReturnStmt * returnStmt ); + void previsit( ast::ThrowStmt * throwStmt ); + void previsit( ast::CatchStmt * catchStmt ); + void previsit( ast::WaitForStmt * stmt ); + + void previsit( ast::SingleInit * singleInit ); + void previsit( ast::ListInit * listInit ); + void previsit( ast::ConstructorInit * ctorInit ); + }; + + void resolve( std::list< ast::ptr >& translationUnit ) { + ast::Pass resolver; + accept_all( translationUnit, resolver ); + } + + void previsit( ast::FunctionDecl * functionDecl ) { + #warning unimplemented; Resolver port in progress + (void)functionDecl; + assert(false); + } + + ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ) { + #warning unimplemented; Resolver port in progress + (void)functionDecl; + assert(false); + return nullptr; + } + + void previsit( ast::ObjectDecl * objectDecl ) { + #warning unimplemented; Resolver port in progress + (void)objectDecl; + assert(false); + } + + void previsit( ast::EnumDecl * enumDecl ) { + #warning unimplemented; Resolver port in progress + (void)enumDecl; + assert(false); + } + + void previsit( ast::StaticAssertDecl * assertDecl ) { + #warning unimplemented; Resolver port in progress + (void)assertDecl; + assert(false); + } + + void previsit( ast::ArrayType * at ) { + #warning unimplemented; Resolver port in progress + (void)at; + assert(false); + } + + void previsit( ast::PointerType * pt ) { + #warning unimplemented; Resolver port in progress + (void)pt; + assert(false); + } + + void previsit( ast::ExprStmt * exprStmt ) { + #warning unimplemented; Resolver port in progress + (void)exprStmt; + assert(false); + } + + void previsit( ast::AsmExpr * asmExpr ) { + #warning unimplemented; Resolver port in progress + (void)asmExpr; + assert(false); + } + + void previsit( ast::AsmStmt * asmStmt ) { + #warning unimplemented; Resolver port in progress + (void)asmStmt; + assert(false); + } + + void previsit( ast::IfStmt * ifStmt ) { + #warning unimplemented; Resolver port in progress + (void)ifStmt; + assert(false); + } + + void previsit( ast::WhileStmt * whileStmt ) { + #warning unimplemented; Resolver port in progress + (void)whileStmt; + assert(false); + } + + void previsit( ast::ForStmt * forStmt ) { + #warning unimplemented; Resolver port in progress + (void)forStmt; + assert(false); + } + + void previsit( ast::SwitchStmt * switchStmt ) { + #warning unimplemented; Resolver port in progress + (void)switchStmt; + assert(false); + } + + void previsit( ast::CaseStmt * caseStmt ) { + #warning unimplemented; Resolver port in progress + (void)caseStmt; + assert(false); + } + + void previsit( ast::BranchStmt * branchStmt ) { + #warning unimplemented; Resolver port in progress + (void)branchStmt; + assert(false); + } + + void previsit( ast::ReturnStmt * returnStmt ) { + #warning unimplemented; Resolver port in progress + (void)returnStmt; + assert(false); + } + + void previsit( ast::ThrowStmt * throwStmt ) { + #warning unimplemented; Resolver port in progress + (void)throwStmt; + assert(false); + } + + void previsit( ast::CatchStmt * catchStmt ) { + #warning unimplemented; Resolver port in progress + (void)catchStmt; + assert(false); + } + + void previsit( ast::WaitForStmt * stmt ) { + #warning unimplemented; Resolver port in progress + (void)stmt; + assert(false); + } + + void previsit( ast::SingleInit * singleInit ) { + #warning unimplemented; Resolver port in progress + (void)singleInit; + assert(false); + } + + void previsit( ast::ListInit * listInit ) { + #warning unimplemented; Resolver port in progress + (void)listInit; + assert(false); + } + + void previsit( ast::ConstructorInit * ctorInit ) { + #warning unimplemented; Resolver port in progress + (void)ctorInit; + assert(false); + } + } // namespace ResolvExpr Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/Resolver.h (revision d76c588058daa6269114595a571223a110ced0ab) @@ -16,5 +16,6 @@ #pragma once -#include // for list +#include // for list +#include // for ptr class ConstructorInit; @@ -23,6 +24,10 @@ class StmtExpr; namespace SymTab { -class Indexer; -} // namespace SymTab + class Indexer; +} // namespace SymTab + +namespace ast { + class Decl; +} // namespace ast namespace ResolvExpr { @@ -40,4 +45,7 @@ /// Resolves with-stmts and with-clauses on functions void resolveWithExprs( std::list< Declaration * > & translationUnit ); + + /// Checks types and binds syntactic constructs to typed representations + void resolve( std::list< ast::ptr >& translationUnit ); } // namespace ResolvExpr Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/Unify.cc (revision d76c588058daa6269114595a571223a110ced0ab) @@ -14,28 +14,29 @@ // -#include // for assertf, assert -#include // for back_insert_iterator, back_inserter -#include // for _Rb_tree_const_iterator, _Rb_tree_i... -#include // for unique_ptr -#include // for set -#include // for string, operator==, operator!=, bas... -#include // for pair, move +#include // for assertf, assert +#include // for back_insert_iterator, back_inserter +#include // for _Rb_tree_const_iterator, _Rb_tree_i... +#include // for unique_ptr +#include // for set +#include // for string, operator==, operator!=, bas... +#include // for pair, move #include #include "AST/Node.hpp" #include "AST/Type.hpp" -#include "Common/PassVisitor.h" // for PassVisitor -#include "FindOpenVars.h" // for findOpenVars -#include "Parser/LinkageSpec.h" // for C -#include "SynTree/Constant.h" // for Constant -#include "SynTree/Declaration.h" // for TypeDecl, TypeDecl::Data, Declarati... -#include "SynTree/Expression.h" // for TypeExpr, Expression, ConstantExpr -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/Type.h" // for Type, TypeInstType, FunctionType -#include "SynTree/Visitor.h" // for Visitor -#include "Tuples/Tuples.h" // for isTtype -#include "TypeEnvironment.h" // for EqvClass, AssertionSet, OpenVarSet +#include "AST/TypeEnvironment.hpp" +#include "Common/PassVisitor.h" // for PassVisitor +#include "FindOpenVars.h" // for findOpenVars +#include "Parser/LinkageSpec.h" // for C +#include "SynTree/Constant.h" // for Constant +#include "SynTree/Declaration.h" // for TypeDecl, TypeDecl::Data, Declarati... +#include "SynTree/Expression.h" // for TypeExpr, Expression, ConstantExpr +#include "SynTree/Mutator.h" // for Mutator +#include "SynTree/Type.h" // for Type, TypeInstType, FunctionType +#include "SynTree/Visitor.h" // for Visitor +#include "Tuples/Tuples.h" // for isTtype +#include "TypeEnvironment.h" // for EqvClass, AssertionSet, OpenVarSet #include "Unify.h" -#include "typeops.h" // for flatten, occurs, commonType +#include "typeops.h" // for flatten, occurs, commonType namespace SymTab { @@ -106,4 +107,12 @@ delete newSecond; return result; + } + + bool typesCompatible( + const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, + const ast::TypeEnvironment & env ) { + #warning unimplemented + assert((first, second, symtab, env, false)); + return false; } @@ -130,4 +139,12 @@ delete newSecond; return result; + } + + bool typesCompatibleIgnoreQualifiers( + const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, + const ast::TypeEnvironment & env ) { + #warning unimplemented + assert((first, second, symtab, env, false)); + return false; } @@ -263,4 +280,13 @@ } + bool unifyInexact( + const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, + ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & openVars, + WidenMode widenMode, const ast::SymbolTable & symtab, const ast::Type *& common ) { + #warning unimplemented + assert((type1, type2, env, need, have, openVars, widenMode, symtab, common, false)); + return false; + } + Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) { Index: src/ResolvExpr/Unify.h =================================================================== --- src/ResolvExpr/Unify.h (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/Unify.h (revision d76c588058daa6269114595a571223a110ced0ab) @@ -18,14 +18,20 @@ #include // for list +#include "AST/TypeEnvironment.hpp" // for TypeEnvironment, AssertionSet, OpenVarSet #include "Common/utility.h" // for deleteAll #include "SynTree/Declaration.h" // for TypeDecl, TypeDecl::Data #include "TypeEnvironment.h" // for AssertionSet, OpenVarSet -#include "WidenMode.h" // for WidenMode +#include "WidenMode.h" // for WidenMode class Type; class TypeInstType; namespace SymTab { -class Indexer; -} // namespace SymTab + class Indexer; +} + +namespace ast { + class SymbolTable; + class Type; +} namespace ResolvExpr { @@ -62,4 +68,9 @@ } + bool unifyInexact( + const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, + ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & openVars, + WidenMode widenMode, const ast::SymbolTable & symtab, const ast::Type *& common ); + } // namespace ResolvExpr Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision c519942642e6eeb1e6281af05f8b60ff0beb335f) +++ src/ResolvExpr/typeops.h (revision d76c588058daa6269114595a571223a110ced0ab) @@ -18,6 +18,9 @@ #include +#include "AST/Fwd.hpp" #include "AST/Node.hpp" +#include "AST/SymbolTable.hpp" #include "AST/Type.hpp" +#include "AST/TypeEnvironment.hpp" #include "SynTree/SynTree.h" #include "SynTree/Type.h" @@ -99,4 +102,12 @@ } + bool typesCompatible( + const ast::Type *, const ast::Type *, const ast::SymbolTable &, + const ast::TypeEnvironment & env = {} ); + + bool typesCompatibleIgnoreQualifiers( + const ast::Type *, const ast::Type *, const ast::SymbolTable &, + const ast::TypeEnvironment & env = {} ); + /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value. Type * extractResultType( FunctionType * functionType ); @@ -115,4 +126,5 @@ // in Occurs.cc bool occurs( Type *type, std::string varName, const TypeEnvironment &env ); + // new AST version in TypeEnvironment.cpp (only place it was used in old AST) template @@ -127,4 +139,5 @@ // in AlternativeFinder.cc void referenceToRvalueConversion( Expression *& expr, Cost & cost ); + const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ); // flatten tuple type into list of types