Changes in / [45161b4d:b11fac4]

Location:

src/GenPoly

Files:

• Box.cc (modified) (4 diffs)
• Lvalue.cc (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -292 +292 @@
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+
+                        /// Enters a new scope for type-variables, adding the type variables from ty
+                        void beginTypeScope( Type *ty );
+                        /// Exits the type-variable scope
+                        void endTypeScope();
                         
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
@@ -1821 +1826 @@
 ////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
 
+                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
+                        scopeTyVars.beginScope();
+                        makeTyVarMap( ty, scopeTyVars );
+                }
+
+                void PolyGenericCalculator::endTypeScope() {
+                        scopeTyVars.endScope();
+                }
+
                 template< typename DeclClass >
                 DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
-                        scopeTyVars.beginScope();
-                        makeTyVarMap( type, scopeTyVars );
+                        beginTypeScope( type );
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
 
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
 
-                        scopeTyVars.endScope();
+                        knownOffsets.endScope();
+                        knownLayouts.endScope();
+                        endTypeScope();
                         return ret;
                 }
@@ -1850 +1867 @@
 
                 Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
-                        scopeTyVars.beginScope();
-                        makeTyVarMap( pointerType, scopeTyVars );
+                        beginTypeScope( pointerType );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars.endScope();
+                        endTypeScope();
                         return ret;
                 }
 
                 Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
-                        scopeTyVars.beginScope();
-                        makeTyVarMap( funcType, scopeTyVars );
+                        beginTypeScope( funcType );
 
                         // make sure that any type information passed into the function is accounted for
@@ -1874 +1889 @@
                         Type *ret = Mutator::mutate( funcType );
 
-                        scopeTyVars.endScope();
+                        endTypeScope();
                         return ret;
                 }

src/GenPoly/Lvalue.cc

@@ -17 +17 @@
 
 #include "Lvalue.h"
+
+#include "GenPoly.h"
 
 #include "SynTree/Declaration.h"
@@ -63 +65 @@
 
         namespace {
-                bool isLvalueRet( FunctionType *function ) {
-                        if ( ! function->get_returnVals().empty() ) {
-                                return function->get_returnVals().front()->get_type()->get_isLvalue();
-                        } else {
-                                return false;
-                        } // if
+                Type* isLvalueRet( FunctionType *function ) {
+                        if ( function->get_returnVals().empty() ) return 0;
+                        Type *ty = function->get_returnVals().front()->get_type();
+                        return ty->get_isLvalue() ? ty : 0;
                 }
 
@@ -107 +107 @@
                         assert( function );
 
-                        std::string typeName;
-                        if ( isLvalueRet( function ) && ! isIntrinsicApp( appExpr ) ) {
+                        Type *funType = isLvalueRet( function );
+                        if ( funType && ! isIntrinsicApp( appExpr ) ) {
+                                Expression *expr = appExpr;
+                                Type *appType = appExpr->get_results().front();
+                                if ( isPolyType( funType ) ) {
+                                        // make sure cast for polymorphic type is inside dereference
+                                        expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) );
+                                }
                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                deref->get_results().push_back( appExpr->get_results().front() );
-                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), deref->get_results().front()->clone() );
-                                deref->get_args().push_back( appExpr );
+                                deref->get_results().push_back( appType->clone() );
+                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
+                                deref->get_args().push_back( expr );
                                 return deref;
                         } else {