Changes in / [2325b57:1b56a7f]

Location:

src

Files:

• GenPoly/Lvalue.cpp (modified) (1 diff)
• ResolvExpr/ConversionCost.cpp (modified) (2 diffs)

src/GenPoly/Lvalue.cpp

@@ -316 +316 @@
                         Warning::RvalueToReferenceConversion, toCString( expr->arg ) );
 
-
-                // allowing conversion in the rvalue to const ref case
-                // use the referenced-to type to create temp variables
-                ast::Type const * targetType = dstType;
-                for (int i = 0; i < diff; ++i) targetType = (strict_dynamic_cast<ast::ReferenceType const *>(targetType))->base;
-
                 static UniqueName tmpNamer( "__ref_tmp_" );
                 ast::ObjectDecl * tmp = new ast::ObjectDecl( expr->arg->location,
                         tmpNamer.newName(),
-                        // ast::deepCopy( expr->arg->result ),
-                        ast::deepCopy (targetType),
+                        ast::deepCopy( expr->arg->result ),
                         new ast::SingleInit( expr->arg->location, expr->arg ) );
                 PRINT( std::cerr << "make tmp: " << tmp << std::endl; )

src/ResolvExpr/ConversionCost.cpp

@@ -250 +250 @@
                         newSrc = new ast::BasicType( ast::BasicKind::UnsignedInt );
                 }
-                if (dstAsRef->base->is_const() ) {
-                        auto cvtCost = conversionCost(newSrc, dstAsRef->base, srcIsLvalue, symtab, env) ;
-                        if (cvtCost == Cost::zero) { // exact match, may use a lvalue src
-                                if ( srcIsLvalue ) {
-                                        if ( src->qualifiers == dstAsRef->base->qualifiers ) {
-                                                return Cost::reference;
-                                        } else if ( src->qualifiers < dstAsRef->base->qualifiers ) {
-                                                return Cost::safe;
-                                        } else {
-                                                return Cost::unsafe;
-                                        }
-                                }
-                                else {
-                                        return Cost::reference;
-                                }
-                        }
-                        else { // not exact match, conversion is needed so lvalueness of src does not matter
-                                return cvtCost + Cost::reference;
-                        }
-                }
                 if ( typesCompatibleIgnoreQualifiers( newSrc, dstAsRef->base, env ) ) {
                         if ( srcIsLvalue ) {
@@ -279 +259 @@
                                         return Cost::unsafe;
                                 }
-                        } else { // rvalue-to-NC-ref conversion
+                        } else if ( dstAsRef->base->is_const() ) {
+                                return Cost::safe;
+                        } else {
                                 return Cost::unsafe;
                         }