Changes in src/GenPoly/Lvalue.cc [a9b1b0c:a16764a6]

File:

• src/GenPoly/Lvalue.cc (modified) (14 diffs)

src/GenPoly/Lvalue.cc

@@ -45 +45 @@
                 Expression * mkDeref( Expression * arg ) {
                         if ( SymTab::dereferenceOperator ) {
-                                // note: reference depth can be arbitrarily deep here, so peel off the outermost pointer/reference, not just pointer because they are effecitvely equivalent in this pass
                                 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
                                 deref->result = new PointerType( Type::Qualifiers(), deref->result );
@@ -60 +59 @@
                 }
 
-                struct ReferenceConversions final : public WithStmtsToAdd {
+                struct ReferenceConversions final {
                         Expression * postmutate( CastExpr * castExpr );
                         Expression * postmutate( AddressExpr * addrExpr );
@@ -115 +114 @@
         }
 
-        void convertLvalue( std::list< Declaration* > & translationUnit ) {
+        void convertLvalue( std::list< Declaration* >& translationUnit ) {
                 PassVisitor<ReferenceConversions> refCvt;
                 PassVisitor<ReferenceTypeElimination> elim;
@@ -151 +150 @@
                                         // use type of return variable rather than expr result type, since it may have been changed to a pointer type
                                         FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
-                                        Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
-                                        return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+                                        Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
+                                        return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
                                 }
                         }
@@ -161 +160 @@
                         if ( isIntrinsicReference( appExpr ) ) {
                                 // eliminate reference types from intrinsic applications - now they return lvalues
-                                Type * result = appExpr->result;
-                                appExpr->result = result->stripReferences()->clone();
-                                appExpr->result->set_lvalue( true );
+                                Type * result = appExpr->get_result();
+                                appExpr->set_result( result->stripReferences()->clone() );
+                                appExpr->get_result()->set_lvalue( true );
                                 if ( ! inIntrinsic ) {
                                         // when not in an intrinsic function, add a cast to
                                         // don't add cast when in an intrinsic function, since they already have the cast
                                         Expression * ret = new CastExpr( appExpr, result );
-                                        std::swap( ret->env, appExpr->env );
+                                        ret->set_env( appExpr->get_env() );
+                                        appExpr->set_env( nullptr );
                                         return ret;
                                 }
@@ -187 +187 @@
                                 assertf( ftype, "Function declaration does not have function type." );
                                 // can be of differing lengths only when function is variadic
-                                assertf( ftype->parameters.size() == appExpr->args.size() || ftype->isVarArgs, "ApplicationExpr args do not match formal parameter type." );
+                                assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
 
 
                                 unsigned int i = 0;
-                                const unsigned int end = ftype->parameters.size();
-                                for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
+                                const unsigned int end = ftype->get_parameters().size();
+                                for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
                                         if (i == end) break;
                                         Expression *& arg = std::get<0>( p );
@@ -198 +198 @@
                                         PRINT(
                                                 std::cerr << "pair<0>: " << arg << std::endl;
-                                                std::cerr << " -- " << arg->result << std::endl;
                                                 std::cerr << "pair<1>: " << formal << std::endl;
                                         )
                                         if ( dynamic_cast<ReferenceType*>( formal ) ) {
-                                                PRINT(
-                                                        std::cerr << "===formal is reference" << std::endl;
-                                                )
-                                                // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
-                                                if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
-                                                        // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
-                                                        PRINT(
-                                                                std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
-                                                        )
-                                                        arg = new AddressExpr( arg );
-                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
-                                                        // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
-                                                        PRINT(
-                                                                std::cerr << "===is non-intrinsic arg in intrinsic call - adding deref to arg" << std::endl;
-                                                        )
-                                                        Type * baseType = InitTweak::getPointerBase( arg->result );
-                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->result ).c_str() );
+                                                if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if
+                                                        if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
+                                                                // if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument
+                                                                PRINT(
+                                                                        std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
+                                                                )
+                                                                arg = new AddressExpr( arg );
+                                                        }
+                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
+                                                        // std::cerr << "===adding deref to arg" << std::endl;
+                                                        // if the parameter is a reference, add a dereference to the reference-typed argument.
+                                                        Type * baseType = InitTweak::getPointerBase( arg->get_result() );
+                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
                                                         PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
-                                                        delete arg->result;
+                                                        delete arg->get_result();
                                                         arg->set_result( ptrType );
                                                         arg = mkDeref( arg );
-                                                        assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
                                                 }
                                         }
@@ -255 +249 @@
                 Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
                         if ( refDepth == 0 ) {
-                                if ( ! isIntrinsicReference( addrExpr->arg ) ) {
+                                if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
                                         // try to avoid ?[?]
-                                        refDepth = addrExpr->arg->result->referenceDepth();
+                                        refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
                                 }
                         }
@@ -286 +280 @@
                         // pointer casts in the right places.
 
-                        // Note: reference depth difference is the determining factor in what code is run, rather than whether something is
-                        // reference type or not, since conversion still needs to occur when both types are references that differ in depth.
-
-                        Type * destType = castExpr->result;
-                        Type * srcType = castExpr->arg->result;
-                        int depth1 = destType->referenceDepth();
-                        int depth2 = srcType->referenceDepth();
-                        int diff = depth1 - depth2;
-
-                        if ( diff > 0 && ! srcType->get_lvalue() ) {
-                                // rvalue to reference conversion -- introduce temporary
-                                // know that reference depth of cast argument is 0, need to introduce n temporaries for reference depth of n, e.g.
-                                //   (int &&&)3;
-                                // becomes
-                                //   int __ref_tmp_0 = 3;
-                                //   int & __ref_tmp_1 = _&_ref_tmp_0;
-                                //   int && __ref_tmp_2 = &__ref_tmp_1;
-                                //   &__ref_tmp_2;
-                                // the last & comes from the remaining reference conversion code
-                                SemanticWarning( castExpr->arg->location, Warning::RvalueToReferenceConversion, toCString( castExpr->arg ) );
-
-                                static UniqueName tempNamer( "__ref_tmp_" );
-                                ObjectDecl * temp = ObjectDecl::newObject( tempNamer.newName(), castExpr->arg->result->clone(), new SingleInit( castExpr->arg ) );
-                                PRINT( std::cerr << "made temp: " << temp << std::endl; )
-                                stmtsToAddBefore.push_back( new DeclStmt( temp ) );
-                                for ( int i = 0; i < depth1-1; i++ ) { // xxx - maybe this should be diff-1? check how this works with reference type for srcType
-                                        ObjectDecl * newTemp = ObjectDecl::newObject( tempNamer.newName(), new ReferenceType( Type::Qualifiers(), temp->type->clone() ), new SingleInit( new AddressExpr( new VariableExpr( temp ) ) ) );
-                                        PRINT( std::cerr << "made temp" << i << ": " << newTemp << std::endl; )
-                                        stmtsToAddBefore.push_back( new DeclStmt( newTemp ) );
-                                        temp = newTemp;
-                                }
-                                // update diff so that remaining code works out correctly
-                                castExpr->arg = new VariableExpr( temp );
-                                PRINT( std::cerr << "update cast to: " << castExpr << std::endl; )
-                                srcType = castExpr->arg->result;
-                                depth2 = srcType->referenceDepth();
-                                diff = depth1 - depth2;
-                                assert( diff == 1 );
-                        }
-
-                        // handle conversion between different depths
-                        PRINT (
-                                if ( depth1 || depth2 ) {
-                                        std::cerr << "destType: " << destType << " / srcType: " << srcType << std::endl;
-                                        std::cerr << "depth: " << depth1 << " / " << depth2 << std::endl;
-                                }
-                        )
-                        if ( diff > 0 ) {
-                                // conversion to type with more depth (e.g. int & -> int &&): add address-of for each level of difference
+                        // conversion to reference type
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
+                                (void)refType;
+                                if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                                        // nothing to do if casting from reference to reference.
+                                        (void)otherRef;
+                                        PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
+                                        if ( isIntrinsicReference( castExpr->get_arg() ) ) {
+                                                Expression * callExpr = castExpr->get_arg();
+                                                PRINT(
+                                                        std::cerr << "but arg is deref -- &" << std::endl;
+                                                        std::cerr << callExpr << std::endl;
+                                                )
+                                                callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
+                                                delete callExpr->get_result();
+                                                callExpr->set_result( refType->clone() );
+                                                // move environment out to new top-level
+                                                callExpr->set_env( castExpr->get_env() );
+                                                castExpr->set_arg( nullptr );
+                                                castExpr->set_env( nullptr );
+                                                delete castExpr;
+                                                return callExpr;
+                                        }
+                                        int depth1 = refType->referenceDepth();
+                                        int depth2 = otherRef->referenceDepth();
+                                        int diff = depth1-depth2;
+                                        if ( diff == 0 ) {
+                                                // conversion between references of the same depth
+                                                assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
+                                                PRINT( std::cerr << castExpr << std::endl; )
+                                                return castExpr;
+                                        } else if ( diff < 0 ) {
+                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
+                                                Expression * ret = castExpr->arg;
+                                                for ( int i = 0; i < diff; ++i ) {
+                                                        ret = mkDeref( ret );
+                                                }
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                ret->result->set_lvalue( true ); // ensure result is lvalue
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
+                                                delete castExpr;
+                                                return ret;
+                                        } else if ( diff > 0 ) {
+                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
+                                                Expression * ret = castExpr->arg;
+                                                for ( int i = 0; i < diff; ++i ) {
+                                                        ret = new AddressExpr( ret );
+                                                }
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
+                                                delete castExpr;
+                                                return ret;
+                                        }
+
+                                        assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
+                                        PRINT( std::cerr << castExpr << std::endl; )
+                                        return castExpr;
+                                } else if ( castExpr->arg->result->get_lvalue() ) {
+                                        // conversion from lvalue to reference
+                                        // xxx - keep cast, but turn into pointer cast??
+                                        // xxx - memory
+                                        PRINT(
+                                                std::cerr << "convert lvalue to reference -- &" << std::endl;
+                                                std::cerr << castExpr->arg << std::endl;
+                                        )
+                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
+                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
+                                                // must keep cast if cast-to type is different from the actual type
+                                                castExpr->arg = ret;
+                                                return castExpr;
+                                        }
+                                        ret->env = castExpr->env;
+                                        delete ret->result;
+                                        ret->result = castExpr->result;
+                                        castExpr->env = nullptr;
+                                        castExpr->arg = nullptr;
+                                        castExpr->result = nullptr;
+                                        delete castExpr;
+                                        return ret;
+                                } else {
+                                        // rvalue to reference conversion -- introduce temporary
+                                }
+                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
+                                (void)refType;
+                                // conversion from reference to rvalue
+                                PRINT(
+                                        std::cerr << "convert reference to rvalue -- *" << std::endl;
+                                        std::cerr << "was = " << castExpr << std::endl;
+                                )
                                 Expression * ret = castExpr->arg;
-                                for ( int i = 0; i < diff; ++i ) {
-                                        ret = new AddressExpr( ret );
-                                }
-                                if ( srcType->get_lvalue() && srcType->get_qualifiers() != strict_dynamic_cast<ReferenceType *>( destType )->base->get_qualifiers() ) {
-                                        // must keep cast if cast-to type is different from the actual type
-                                        castExpr->arg = ret;
-                                        return castExpr;
-                                }
-                                ret->env = castExpr->env;
-                                delete ret->result;
-                                ret->result = castExpr->result;
-                                castExpr->env = nullptr;
-                                castExpr->arg = nullptr;
-                                castExpr->result = nullptr;
-                                delete castExpr;
-                                return ret;
-                        } else if ( diff < 0 ) {
-                                // conversion to type with less depth (e.g. int && -> int &): add dereferences for each level of difference
-                                diff = -diff; // care only about magnitude now
-                                Expression * ret = castExpr->arg;
-                                for ( int i = 0; i < diff; ++i ) {
+                                TypeSubstitution * env = castExpr->env;
+                                castExpr->set_env( nullptr );
+                                if ( ! isIntrinsicReference( ret ) ) {
+                                        // dereference if not already dereferenced
                                         ret = mkDeref( ret );
                                 }
-                                if ( ! ResolvExpr::typesCompatibleIgnoreQualifiers( destType->stripReferences(), srcType->stripReferences(), SymTab::Indexer() ) ) {
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
+                                        // can remove cast if types are compatible, changing expression type to value type
+                                        ret->result = castExpr->result->clone();
+                                        ret->result->set_lvalue( true );  // ensure result is lvalue
+                                        castExpr->arg = nullptr;
+                                        delete castExpr;
+                                } else {
                                         // must keep cast if types are different
                                         castExpr->arg = ret;
-                                        return castExpr;
-                                }
-                                ret->env = castExpr->env;
-                                delete ret->result;
-                                ret->result = castExpr->result;
-                                ret->result->set_lvalue( true ); // ensure result is lvalue
-                                castExpr->env = nullptr;
-                                castExpr->arg = nullptr;
-                                castExpr->result = nullptr;
-                                delete castExpr;
+                                        ret = castExpr;
+                                }
+                                ret->set_env( env );
+                                PRINT( std::cerr << "now: " << ret << std::endl; )
                                 return ret;
-                        } else {
-                                assert( diff == 0 );
-                                // conversion between references of the same depth
-                                return castExpr;
-                        }
+                        }
+                        return castExpr;
                 }
 
                 Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
-                        Type * base = refType->base;
+                        Type * base = refType->get_base();
                         Type::Qualifiers qualifiers = refType->get_qualifiers();
-                        refType->base = nullptr;
+                        refType->set_base( nullptr );
                         delete refType;
                         return new PointerType( qualifiers, base );
@@ -391 +414 @@
                 Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
                         if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
-                                Expression * arg1 = commaExpr->arg1->clone();
-                                Expression * arg2 = commaExpr->arg2->clone();
+                                Expression * arg1 = commaExpr->get_arg1()->clone();
+                                Expression * arg2 = commaExpr->get_arg2()->clone();
                                 Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
-                                ret->env = expr->env;
-                                expr->env = nullptr;
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
                                 delete expr;
                                 return ret;
                         } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
-                                Expression * arg1 = condExpr->arg1->clone();
-                                Expression * arg2 = condExpr->arg2->clone();
-                                Expression * arg3 = condExpr->arg3->clone();
+                                Expression * arg1 = condExpr->get_arg1()->clone();
+                                Expression * arg2 = condExpr->get_arg2()->clone();
+                                Expression * arg3 = condExpr->get_arg3()->clone();
                                 ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
-                                ret->env = expr->env;
-                                expr->env = nullptr;
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
                                 delete expr;
 
@@ -413 +436 @@
                                 AssertionSet needAssertions, haveAssertions;
                                 OpenVarSet openVars;
-                                unify( ret->arg2->result, ret->arg3->result, newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
-                                ret->result = commonType ? commonType : ret->arg2->result->clone();
+                                unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+                                ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
                                 return ret;
                         }
@@ -421 +444 @@
 
                 Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
-                        return applyTransformation( memExpr, memExpr->aggregate, [=]( Expression * aggr ) { return new MemberExpr( memExpr->member, aggr ); } );
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
                 }
 
                 Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
-                        return applyTransformation( addrExpr, addrExpr->arg, []( Expression * arg ) { return new AddressExpr( arg ); } );
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
                 }
 
                 Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
-                        Expression * arg = addrExpr->arg;
+                        Expression * arg = addrExpr->get_arg();
                         if ( isIntrinsicReference( arg ) ) {
                                 std::string fname = InitTweak::getFunctionName( arg );
@@ -435 +458 @@
                                         Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
                                         Expression * ret = arg0;
-                                        ret->set_env( addrExpr->env );
+                                        ret->set_env( addrExpr->get_env() );
                                         arg0 = nullptr;
-                                        addrExpr->env = nullptr;
+                                        addrExpr->set_env( nullptr );
                                         delete addrExpr;
                                         return ret;
@@ -464 +487 @@
                                         // }
                                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
-                                                Expression * ret = addrExpr->arg;
-                                                ret->env = appExpr->env;
-                                                addrExpr->arg = nullptr;
-                                                appExpr->env = nullptr;
+                                                Expression * ret = addrExpr->get_arg();
+                                                ret->set_env( appExpr->get_env() );
+                                                addrExpr->set_arg( nullptr );
+                                                appExpr->set_env( nullptr );
                                                 delete appExpr;
                                                 return ret;