Changes in / [0db817e:d2e2865]

Location:

src

Files:

• Concurrency/Waitfor.cc (modified) (8 diffs)
• InitTweak/FixInit.cc (modified) (6 diffs)
• MakeLibCfa.cc (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (18 diffs)
• ResolvExpr/Resolver.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (1 diff)
• libcfa/Makefile.am (modified) (1 diff)
• libcfa/Makefile.in (modified) (1 diff)
• tests/.expect/64/KRfunctions.txt (modified) (2 diffs)
• tests/.expect/64/attributes.txt (modified) (6 diffs)
• tests/.expect/64/declarationSpecifier.txt (modified) (26 diffs)
• tests/.expect/64/extension.txt (modified) (2 diffs)
• tests/.expect/64/gccExtensions.txt (modified) (6 diffs)
• tests/.expect/64/literals.txt (modified) (6 diffs)
• tests/.expect/references.txt (modified) (1 diff)
• tests/references.c (modified) (3 diffs)

src/Concurrency/Waitfor.cc

@@ -190 +190 @@
 
                 Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
-                        std::unique_ptr< Expression > expr( makeOpAssign(
+                        Expression * expr = makeOpAssign(
                                 makeOpMember(
                                         makeOpIndex(
@@ -199 +199 @@
                                 ),
                                 value
-                        ) );
-
-                        return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
+                        );
+
+                        ResolvExpr::findVoidExpression( expr, indexer );
+
+                        return new ExprStmt( noLabels, expr );
                 }
 
@@ -313 +315 @@
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
 
-                UntypedExpr * set = new UntypedExpr(
+                Expression * set = new UntypedExpr(
                         new NameExpr( "__builtin_memset" ),
                         {
@@ -322 +324 @@
                 );
 
-                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
-                delete set;
-
-                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
+                ResolvExpr::findVoidExpression( set, indexer );
+
+                stmt->push_back( new ExprStmt( noLabels, set ) );
 
                 return acceptables;
@@ -346 +347 @@
 
         Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
-                Expression * untyped = new UntypedExpr(
+                Expression * expr = new UntypedExpr(
                         new NameExpr( "?=?" ),
                         {
@@ -354 +355 @@
                 );
 
-                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
-                delete untyped;
+                ResolvExpr::findVoidExpression( expr, indexer );
 
                 return new ExprStmt( noLabels, expr );
@@ -379 +379 @@
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
-                                        Expression * untyped = new CastExpr(
+                                        Expression * init = new CastExpr(
                                                 new UntypedExpr(
                                                         new NameExpr( "get_monitor" ),
@@ -393 +393 @@
                                         );
 
-                                        Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
-                                        delete untyped;
+                                        ResolvExpr::findSingleExpression( init, indexer );
                                         return new SingleInit( init );
                                 })

src/InitTweak/FixInit.cc

@@ -367 +367 @@
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
-                        Expression * untyped = exprStmt->get_expr();
+                        Expression * resolved = exprStmt->expr;
+                        exprStmt->expr = nullptr; // take ownership of expr
 
                         // resolve copy constructor
                         // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
                         // (VariableExpr and already resolved expression)
-                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
+                        ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
@@ -381 +382 @@
                                 resolved->set_env( nullptr );
                         } // if
-
                         delete stmt;
                         return resolved;
@@ -1112 +1112 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
+                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
                         // add object to the indexer assumes that there will be no name collisions
                         // in generated code. If this changes, add mutate methods for entities with
@@ -1120 +1120 @@
                 }
 
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
                 }
 
@@ -1146 +1148 @@
 
                         // resolve assignment and dispose of new env
-                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
-                        delete resolvedAssign->env;
-                        resolvedAssign->env = nullptr;
-                        delete assign;
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
 
                         // for constructor expr:
@@ -1158 +1159 @@
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
-                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/MakeLibCfa.cc

@@ -119 +119 @@
                         newDecls.push_back( funcDecl );
 
+                        Statement * stmt = nullptr;
                         switch ( opInfo.type ) {
                           case CodeGen::OT_INDEX:
@@ -128 +129 @@
                           case CodeGen::OT_POSTFIXASSIGN:
                           case CodeGen::OT_INFIXASSIGN:
+                                        // return the recursive call
+                                        stmt = new ReturnStmt( noLabels, newExpr );
+                                        break;
                           case CodeGen::OT_CTOR:
                           case CodeGen::OT_DTOR:
-                                // return the recursive call
-                                        funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                                        // execute the recursive call
+                                        stmt = new ExprStmt( noLabels, newExpr );
                                         break;
                           case CodeGen::OT_CONSTANT:
@@ -138 +142 @@
                                 assert( false );
                         } // switch
+                        funcDecl->get_statements()->push_back( stmt );
                 }
         } // namespace

src/ResolvExpr/AlternativeFinder.cc

@@ -1268 +1268 @@
                 // O(N^2) checks of d-types with e-types
                 for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
-                        Type * toType = resolveTypeof( initAlt.type, indexer );
+                        Type * toType = resolveTypeof( initAlt.type->clone(), indexer );
                         SymTab::validateType( toType, &indexer );
                         adjustExprType( toType, env, indexer );

src/ResolvExpr/Resolver.cc

@@ -109 +109 @@
 
         namespace {
-                void finishExpr( Expression *expr, const TypeEnvironment &env ) {
-                        expr->set_env( new TypeSubstitution );
+                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                        expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->get_env() );
                 }
         } // namespace
 
-        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 global_renamer.reset();
                 TypeEnvironment env;
                 Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
-                finishExpr( newExpr, env );
-                return newExpr;
-        }
-
-        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                finishExpr( newExpr, env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+
+        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
+                if ( ! untyped ) return;
                 TypeEnvironment env;
                 AlternativeFinder finder( indexer, env );
@@ -129 +131 @@
                 #if 0
                 if ( finder.get_alternatives().size() != 1 ) {
-                        std::cout << "untyped expr is ";
-                        untyped->print( std::cout );
-                        std::cout << std::endl << "alternatives are:";
-                        for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                i->print( std::cout );
+                        std::cerr << "untyped expr is ";
+                        untyped->print( std::cerr );
+                        std::cerr << std::endl << "alternatives are:";
+                        for ( const Alternative & alt : finder.get_alternatives() ) {
+                                alt.print( std::cerr );
                         } // for
                 } // if
@@ -140 +142 @@
                 Alternative &choice = finder.get_alternatives().front();
                 Expression *newExpr = choice.expr->clone();
-                finishExpr( newExpr, choice.env );
-                return newExpr;
+                finishExpr( newExpr, choice.env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
+                assert( untyped && type );
+                untyped = new CastExpr( untyped, type );
+                findSingleExpression( untyped, indexer );
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( untyped ) ) {
+                        if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
+                                // cast is to the same type as its argument, so it's unnecessary -- remove it
+                                untyped = castExpr->arg;
+                                castExpr->arg = nullptr;
+                                delete castExpr;
+                        }
+                }
         }
 
@@ -157 +174 @@
                 }
 
-                Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
@@ -186 +203 @@
                                 throw SemanticError( "No interpretations for case control expression", untyped );
                         } // if
-                        finishExpr( newExpr, *newEnv );
-                        return newExpr;
+                        finishExpr( newExpr, *newEnv, untyped->env );
+                        delete untyped;
+                        untyped = newExpr;
                 }
 
@@ -212 +230 @@
         void Resolver::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
-                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, indexer );
-                        delete type->get_dimension();
-                        type->set_dimension( newExpr );
+                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
                 }
         }
@@ -268 +283 @@
         void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
-                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
-                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
-                delete exprStmt->get_expr();
-                exprStmt->set_expr( newExpr );
+                assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
+                findVoidExpression( exprStmt->expr, indexer );
         }
 
         void Resolver::previsit( AsmExpr *asmExpr ) {
                 visit_children = false;
-                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
-                delete asmExpr->get_operand();
-                asmExpr->set_operand( newExpr );
+                findVoidExpression( asmExpr->operand, indexer );
                 if ( asmExpr->get_inout() ) {
-                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
-                        delete asmExpr->get_inout();
-                        asmExpr->set_inout( newExpr );
+                        findVoidExpression( asmExpr->inout, indexer );
                 } // if
         }
@@ -293 +302 @@
 
         void Resolver::previsit( IfStmt *ifStmt ) {
-                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
-                delete ifStmt->get_condition();
-                ifStmt->set_condition( newExpr );
+                findSingleExpression( ifStmt->condition, indexer );
         }
 
         void Resolver::previsit( WhileStmt *whileStmt ) {
-                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
-                delete whileStmt->get_condition();
-                whileStmt->set_condition( newExpr );
+                findSingleExpression( whileStmt->condition, indexer );
         }
 
         void Resolver::previsit( ForStmt *forStmt ) {
-                if ( forStmt->get_condition() ) {
-                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
-                        delete forStmt->get_condition();
-                        forStmt->set_condition( newExpr );
+                if ( forStmt->condition ) {
+                        findSingleExpression( forStmt->condition, indexer );
                 } // if
 
-                if ( forStmt->get_increment() ) {
-                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
-                        delete forStmt->get_increment();
-                        forStmt->set_increment( newExpr );
+                if ( forStmt->increment ) {
+                        findVoidExpression( forStmt->increment, indexer );
                 } // if
         }
@@ -320 +321 @@
         void Resolver::previsit( SwitchStmt *switchStmt ) {
                 GuardValue( currentObject );
-                Expression *newExpr;
-                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
-                delete switchStmt->get_condition();
-                switchStmt->set_condition( newExpr );
-
-                currentObject = CurrentObject( newExpr->get_result() );
+                findIntegralExpression( switchStmt->condition, indexer );
+
+                currentObject = CurrentObject( switchStmt->condition->result );
         }
 
@@ -332 +330 @@
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
-                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
-                        Expression * newExpr = findSingleExpression( castExpr, indexer );
-                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
-                        caseStmt->set_condition( castExpr->get_arg() );
-                        castExpr->set_arg( nullptr );
+                        // must remove cast from case statement because RangeExpr cannot be cast.
+                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
+                        findSingleExpression( newExpr, indexer );
+                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
+                        caseStmt->condition = castExpr->arg;
+                        castExpr->arg = nullptr;
                         delete castExpr;
                 }
@@ -345 +344 @@
                 // must resolve the argument for a computed goto
                 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
-                        if ( Expression * arg = branchStmt->get_computedTarget() ) {
-                                VoidType v = Type::Qualifiers();                // cast to void * for the alternative finder
-                                PointerType pt( Type::Qualifiers(), v.clone() );
-                                CastExpr * castExpr = new CastExpr( arg, pt.clone() );
-                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
-                                branchStmt->set_target( newExpr );
+                        if ( branchStmt->computedTarget ) {
+                                // computed goto argument is void *
+                                findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
                         } // if
                 } // if
@@ -357 +353 @@
         void Resolver::previsit( ReturnStmt *returnStmt ) {
                 visit_children = false;
-                if ( returnStmt->get_expr() ) {
-                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, indexer );
-                        delete castExpr;
-                        returnStmt->set_expr( newExpr );
+                if ( returnStmt->expr ) {
+                        findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
                 } // if
         }
@@ -372 +365 @@
                                 indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
-                        Expression * wrapped = new CastExpr(
-                                throwStmt->get_expr(),
-                                new PointerType(
-                                        noQualifiers,
-                                        new StructInstType(
-                                                noQualifiers,
-                                                exception_decl
-                                                )
-                                        )
-                                );
-                        Expression * newExpr = findSingleExpression( wrapped, indexer );
-                        throwStmt->set_expr( newExpr );
+                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
+                        findSingleExpression( throwStmt->expr, exceptType, indexer );
                 }
         }
 
         void Resolver::previsit( CatchStmt *catchStmt ) {
-                if ( catchStmt->get_cond() ) {
-                        Expression * wrapped = new CastExpr(
-                                catchStmt->get_cond(),
-                                new BasicType( noQualifiers, BasicType::Bool )
-                                );
-                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
-                }
-        }
-
-        inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
-                if( !expr ) return;
-                Expression * newExpr = findSingleExpression( expr, indexer );
-                delete expr;
-                expr = newExpr;
-        }
-
-        inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
-                if( !expr ) return;
-                Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
-                delete expr;
-                expr = newExpr;
+                if ( catchStmt->cond ) {
+                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                }
         }
 
@@ -578 +543 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsIf( clause.condition, this->indexer );
+                        findSingleExpression( clause.condition, this->indexer );
                         clause.statement->accept( *visitor );
                 }
@@ -587 +552 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
-                        resolveAsIf  ( stmt->timeout.condition, this->indexer );
+                        findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        findSingleExpression( stmt->timeout.condition, this->indexer );
                         stmt->timeout.statement->accept( *visitor );
                 }
@@ -595 +560 @@
                         // Resolve the conditions as if it were an IfStmt
                         // Resolve the statments normally
-                        resolveAsIf( stmt->orelse.condition, this->indexer );
+                        findSingleExpression( stmt->orelse.condition, this->indexer );
                         stmt->orelse.statement->accept( *visitor );
                 }
@@ -612 +577 @@
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
-                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
-                Expression * newExpr = findSingleExpression( untyped, indexer );
+                Expression * newExpr = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
+                findSingleExpression( newExpr, indexer );
                 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 
@@ -620 +585 @@
 
                 // discard InitExpr wrapper and retain relevant pieces
-                newExpr = initExpr->get_expr();
-                newExpr->set_env( initExpr->get_env() );
-                initExpr->set_expr( nullptr );
-                initExpr->set_env( nullptr );
+                newExpr = initExpr->expr;
+                initExpr->expr = nullptr;
+                std::swap( initExpr->env, newExpr->env );
                 delete initExpr;
 

src/ResolvExpr/Resolver.h

@@ -30 +30 @@
         void resolve( std::list< Declaration * > translationUnit );
         void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
-        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
-        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
-        Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/SymTab/Validate.cc

@@ -276 +276 @@
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
-                acceptAll( translationUnit, fpd );
+                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines
                 ArrayLength::computeLength( translationUnit );
                 acceptAll( translationUnit, finder );

src/libcfa/Makefile.am

@@ -31 +31 @@
 
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
-         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
-         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 
 EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@

src/libcfa/Makefile.in

@@ -1498 +1498 @@
 
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
-         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
-         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 
 # extensionless header files are overridden by -o flag in default makerule => explicitly override default rule to silently do nothing

src/tests/.expect/64/KRfunctions.txt

@@ -34 +34 @@
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
-    return ((struct S )___ret__2sS_1);
+    return ___ret__2sS_1;
 }
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
@@ -65 +65 @@
     signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
-    return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ___retval_f10__PFPi_ii__1;
 }
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{

src/tests/.expect/64/attributes.txt

@@ -24 +24 @@
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
-    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    return ___ret__13s__anonymous0_1;
 }
 __attribute__ ((unused)) struct Agn1;
@@ -42 +42 @@
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
-    return ((struct Agn2 )___ret__5sAgn2_1);
+    return ___ret__5sAgn2_1;
 }
 enum __attribute__ ((unused)) __anonymous1 {
@@ -114 +114 @@
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
-    return ((struct Fdl )___ret__4sFdl_1);
+    return ___ret__4sFdl_1;
 }
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
@@ -301 +301 @@
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
-        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+        return ___ret__13s__anonymous4_2;
     }
     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
@@ -320 +320 @@
         enum __anonymous5 ___ret__13e__anonymous5_2;
         ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
-        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+        return ___ret__13e__anonymous5_2;
     }
     ((void)sizeof(enum __anonymous5 ));
@@ -350 +350 @@
     struct Vad ___ret__4sVad_1;
     ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
-    return ((struct Vad )___ret__4sVad_1);
-}
+    return ___ret__4sVad_1;
+}

src/tests/.expect/64/declarationSpecifier.txt

@@ -33 +33 @@
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
-    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    return ___ret__13s__anonymous0_1;
 }
 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
@@ -59 +59 @@
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
-    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+    return ___ret__13s__anonymous1_1;
 }
 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
@@ -85 +85 @@
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
-    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+    return ___ret__13s__anonymous2_1;
 }
 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
@@ -111 +111 @@
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
-    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+    return ___ret__13s__anonymous3_1;
 }
 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
@@ -137 +137 @@
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
-    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+    return ___ret__13s__anonymous4_1;
 }
 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
@@ -163 +163 @@
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
-    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+    return ___ret__13s__anonymous5_1;
 }
 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
@@ -189 +189 @@
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
-    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+    return ___ret__13s__anonymous6_1;
 }
 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
@@ -215 +215 @@
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
-    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+    return ___ret__13s__anonymous7_1;
 }
 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
@@ -249 +249 @@
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
-    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+    return ___ret__13s__anonymous8_1;
 }
 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
@@ -275 +275 @@
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
-    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+    return ___ret__13s__anonymous9_1;
 }
 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
@@ -301 +301 @@
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
-    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+    return ___ret__14s__anonymous10_1;
 }
 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
@@ -327 +327 @@
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
-    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+    return ___ret__14s__anonymous11_1;
 }
 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
@@ -353 +353 @@
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
-    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+    return ___ret__14s__anonymous12_1;
 }
 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
@@ -379 +379 @@
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
-    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+    return ___ret__14s__anonymous13_1;
 }
 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
@@ -405 +405 @@
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
-    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+    return ___ret__14s__anonymous14_1;
 }
 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
@@ -431 +431 @@
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
-    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+    return ___ret__14s__anonymous15_1;
 }
 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
@@ -473 +473 @@
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
-    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+    return ___ret__14s__anonymous16_1;
 }
 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
@@ -499 +499 @@
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
-    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+    return ___ret__14s__anonymous17_1;
 }
 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
@@ -525 +525 @@
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
-    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+    return ___ret__14s__anonymous18_1;
 }
 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
@@ -551 +551 @@
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
-    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+    return ___ret__14s__anonymous19_1;
 }
 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
@@ -577 +577 @@
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
-    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+    return ___ret__14s__anonymous20_1;
 }
 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
@@ -603 +603 @@
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
-    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+    return ___ret__14s__anonymous21_1;
 }
 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
@@ -629 +629 @@
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
-    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+    return ___ret__14s__anonymous22_1;
 }
 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
@@ -655 +655 @@
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
-    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+    return ___ret__14s__anonymous23_1;
 }
 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
@@ -672 +672 @@
     __attribute__ ((unused)) signed int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
@@ -689 +689 @@
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((signed int )___retval_main__i_1);
-}
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/extension.txt

@@ -38 +38 @@
     ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
-    return ((struct S )___ret__2sS_1);
+    return ___ret__2sS_1;
 }
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
@@ -71 +71 @@
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
-    return ((union U )___ret__2uU_1);
+    return ___ret__2uU_1;
 }
 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){

src/tests/.expect/64/gccExtensions.txt

@@ -64 +64 @@
         ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
-        return ((struct S )___ret__2sS_2);
+        return ___ret__2sS_2;
     }
     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
@@ -114 +114 @@
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
-        return ((struct s2 )___ret__3ss2_2);
+        return ___ret__3ss2_2;
     }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
@@ -135 +135 @@
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
-        return ((struct s3 )___ret__3ss3_2);
+        return ___ret__3ss3_2;
     }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
@@ -158 +158 @@
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
-        return ((struct s4 )___ret__3ss4_2);
+        return ___ret__3ss4_2;
     }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
@@ -169 +169 @@
     signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
@@ -186 +186 @@
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
 }

src/tests/.expect/64/literals.txt

@@ -77 +77 @@
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
     ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), ___src__16s_Istream_cstrUC_1));
-    return ((struct _Istream_cstrUC )___ret__16s_Istream_cstrUC_1);
+    return ___ret__16s_Istream_cstrUC_1;
 }
 static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1){
@@ -109 +109 @@
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
     ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), ___src__15s_Istream_cstrC_1));
-    return ((struct _Istream_cstrC )___ret__15s_Istream_cstrC_1);
+    return ___ret__15s_Istream_cstrC_1;
 }
 static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1){
@@ -230 +230 @@
 
     ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), ___src__9sofstream_1));
-    return ((struct ofstream )___ret__9sofstream_1);
+    return ___ret__9sofstream_1;
 }
 static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1){
@@ -437 +437 @@
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
     ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), ___src__9sifstream_1));
-    return ((struct ifstream )___ret__9sifstream_1);
+    return ___ret__9sifstream_1;
 }
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
@@ -1363 +1363 @@
     ((void)L"a" "b" "c");
     ((void)(___retval_main__i_1=0) /* ?{} */);
-    return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
 }
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
@@ -1378 +1378 @@
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
-    return ((signed int )___retval_main__i_1);
-}
+    return ___retval_main__i_1;
+}

src/tests/.expect/references.txt

@@ -2 +2 @@
 12 12 1
 12 12 1 1
+13 1 12
+14 14
 Default constructing a Y
 Copy constructing a Y

src/tests/references.c

@@ -37 +37 @@
 int * toptr( int & r ) { return &r; }
 
+void changeRef( int & r ) {
+        r++;
+}
+
 int main() {
         int x = 123456, *p1 = &x, **p2 = &p1, ***p3 = &p2,
@@ -43 +47 @@
         **p3 = &x;                          // change p1
         *p3 = &p1;                          // change p2
-        int y, z, & ar[3] = { x, y, z };    // initialize array of references
+        int y = 0, z = 11, & ar[3] = { x, y, z };    // initialize array of references
 
         // test that basic reference properties are true - r1 should be an alias for x
@@ -52 +56 @@
         // test that functions using basic references work
         printf("%d %d %d %d\n", toref(&x), toref(p1), toptr(r1) == toptr(x), toptr(r1) == &x);
+
+        changeRef( x );
+        changeRef( y );
+        changeRef( z );
+        printf("%d %d %d\n", x, y, z);
+        changeRef( r1 );
+        printf("%d %d\n", r1, x);
 
         // test that reference members are not implicitly constructed/destructed/assigned