Changes in src/GenPoly/Box.cc [acd7c5dd:2a7b3ca]

File:

• src/GenPoly/Box.cc (modified) (7 diffs)

src/GenPoly/Box.cc

@@ -27 +27 @@
 #include "Box.h"
 #include "DeclMutator.h"
-#include "Lvalue.h"
+#include "PolyMutator.h"
 #include "FindFunction.h"
-#include "PolyMutator.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -203 +202 @@
                 };
 
-                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
                 class Pass3 final : public PolyMutator {
                   public:
@@ -211 +210 @@
                         using PolyMutator::mutate;
                         virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
-                        virtual Declaration *mutate( StructDecl *structDecl ) override;
-                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
                         virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
                         virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
@@ -756 +753 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
+                        assert( arg->has_result() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                Type * newType = arg->get_result()->clone();
-                                if ( env ) env->apply( newType );
-                                std::auto_ptr<Type> manager( newType );
-                                if ( isPolyType( newType ) ) {
+                                if ( isPolyType( arg->get_result() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_lvalue() ) {
-                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        // xxx - need to test that this code is still reachable
+                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
+                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
+                                        } else {
+                                                arg = new AddressExpr( arg );
+                                        }
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
                                                 // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
@@ -1749 +1748 @@
 
                 Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
+                        Type *ty = sizeofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
@@ -1759 +1758 @@
 
                 Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
-                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
+                        Type *ty = alignofExpr->get_type();
                         if ( findGeneric( ty ) ) {
                                 Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
@@ -1869 +1868 @@
                 }
 
-                /// Strips the members from a generic aggregate
-                void stripGenericMembers(AggregateDecl* decl) {
-                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
-                }
-
-                Declaration *Pass3::mutate( StructDecl *structDecl ) {
-                        stripGenericMembers( structDecl );
-                        return structDecl;
-                }
-
-                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
-                        stripGenericMembers( unionDecl );
-                        return unionDecl;
-                }
-
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
 //   Initializer *init = 0;