Changes in / [2ff76d25:fcf3493]

File:

• src/GenPoly/Box.cpp (modified) (9 diffs)

src/GenPoly/Box.cpp

@@ -30 +30 @@
 #include "Common/UniqueName.hpp"       // for UniqueName
 #include "GenPoly/FindFunction.hpp"    // for findFunction
-#include "GenPoly/GenPoly.hpp"         // for getFunctionType, isPolyType, ...
+#include "GenPoly/GenPoly.hpp"         // for getFunctionType, ...
 #include "GenPoly/Lvalue.hpp"          // for generalizedLvalue
 #include "GenPoly/ScopedSet.hpp"       // for ScopedSet
@@ -670 +670 @@
 }
 
-// Get the referent (base type of pointer). Must succeed.
-ast::Type const * getReferentType( ast::ptr<ast::Type> const & type ) {
-        auto pointerType = type.strict_as<ast::PointerType>();
-        assertf( pointerType->base, "getReferentType: pointer base is nullptr." );
-        return pointerType->base.get();
-}
-
 bool isPolyDeref( ast::UntypedExpr const * expr,
                 TypeVarMap const & typeVars,
                 ast::TypeSubstitution const * typeSubs ) {
-        auto name = expr->func.as<ast::NameExpr>();
-        if ( name && "*?" == name->name ) {
-                // It's a deref.
-                // Must look under the * (and strip its ptr-ty) because expr's
-                // result could be ar/ptr-decayed.  If expr.inner:T(*)[n], then
-                // expr is a poly deref, even though expr:T*, which is not poly.
-                auto referentType = getReferentType( expr->args.front()->result );
-                return isPolyType( referentType, typeVars, typeSubs );
+        if ( auto name = expr->func.as<ast::NameExpr>() ) {
+                if ( "*?" == name->name ) {
+                        // It's a deref.
+                        // Must look under the * (and strip its ptr-ty) because expr's
+                        // result could be ar/ptr-decayed.  If expr.inner:T(*)[n], then
+                        // expr is a poly deref, even though expr:T*, which is not poly.
+                        auto ptrExpr = expr->args.front();
+                        auto ptrTy = ptrExpr->result.as<ast::PointerType>();
+                        assert(ptrTy); // thing being deref'd must be pointer
+                        auto referentTy = ptrTy->base;
+                        assert(referentTy);
+                        return isPolyType( referentTy, typeVars, typeSubs );
+                }
         }
         return false;
@@ -1201 +1199 @@
                 assert( 2 == expr->args.size() );
 
-                ast::ptr<ast::Type> const & argType1 = expr->args.front()->result;
-                ast::ptr<ast::Type> const & argType2 = expr->args.back()->result;
-
-                // Two Cases: a[i] with first arg poly ptr, i[a] with second arg poly ptr
-                bool isPoly1 = isPolyPtr( argType1, scopeTypeVars, typeSubs ) != nullptr;
-                bool isPoly2 = isPolyPtr( argType2, scopeTypeVars, typeSubs ) != nullptr;
+                ast::Type const * arg1Ty = expr->args.front()->result;
+                ast::Type const * arg2Ty = expr->args.back()->result;
+
+                // two cases: a[i] with first arg poly ptr, i[a] with second arg poly ptr
+                bool isPoly1 = isPolyPtr( arg1Ty, scopeTypeVars, typeSubs ) != nullptr;
+                bool isPoly2 = isPolyPtr( arg2Ty, scopeTypeVars, typeSubs ) != nullptr;
 
                 // If neither argument is a polymorphic pointer, do nothing.
@@ -1223 +1221 @@
                                 new ast::NameExpr( location, "?+?" ) );
                 if ( isPoly1 ) {
-                        auto referentType = getReferentType( argType1 );
+                        assert( arg1Ty );
+                        auto arg1TyPtr = dynamic_cast<ast::PointerType const * >( arg1Ty );
+                        assert( arg1TyPtr );
                         auto multiply = ast::UntypedExpr::createCall( location2, "?*?", {
                                 expr->args.back(),
-                                new ast::SizeofExpr( location1, deepCopy( referentType ) ),
+                                new ast::SizeofExpr( location1, deepCopy( arg1TyPtr->base ) ),
                         } );
                         ret->args.push_back( expr->args.front() );
@@ -1232 +1232 @@
                 } else {
                         assert( isPoly2 );
-                        auto referentType = getReferentType( argType2 );
+                        assert( arg2Ty );
+                        auto arg2TyPtr = dynamic_cast<ast::PointerType const * >( arg2Ty );
+                        assert( arg2TyPtr );
                         auto multiply = ast::UntypedExpr::createCall( location1, "?*?", {
                                 expr->args.front(),
-                                new ast::SizeofExpr( location2, deepCopy( referentType ) ),
+                                new ast::SizeofExpr( location2, deepCopy( arg2TyPtr->base ) ),
                         } );
                         ret->args.push_back( multiply );
@@ -1248 +1250 @@
                 assert( 1 == expr->args.size() );
 
+                auto ptrExpr = expr->args.front();
+                auto ptrTy = ptrExpr->result.as<ast::PointerType>();
+                assert(ptrTy); // thing being deref'd must be pointer
+                auto referentTy = ptrTy->base;
+                assert(referentTy);
+
                 // If this isn't for a poly type, then do nothing.
-                auto referentType = getReferentType( expr->args.front()->result );
-                if ( !isPolyType( referentType, scopeTypeVars, typeSubs ) ) {
+                if ( !isPolyType( referentTy, scopeTypeVars, typeSubs ) ) {
                         return expr;
                 }
@@ -1315 +1322 @@
                 assert( 2 == expr->args.size() );
 
-                ast::ptr<ast::Type> const & argType1 = expr->args.front()->result;
-                ast::ptr<ast::Type> const & argType2 = expr->args.back()->result;
-
-                bool isPoly1 = isPolyPtr( argType1, scopeTypeVars, typeSubs ) != nullptr;
-                bool isPoly2 = isPolyPtr( argType2, scopeTypeVars, typeSubs ) != nullptr;
+                ast::Type const * arg1Ty = expr->args.front()->result;
+                ast::Type const * arg2Ty = expr->args.back()->result;
+
+                bool isPoly1 = isPolyPtr( arg1Ty, scopeTypeVars, typeSubs ) != nullptr;
+                bool isPoly2 = isPolyPtr( arg2Ty, scopeTypeVars, typeSubs ) != nullptr;
 
                 CodeLocation const & location = expr->location;
                 CodeLocation const & location1 = expr->args.front()->location;
                 CodeLocation const & location2 = expr->args.back()->location;
-                // LHS - RHS -> (LHS - RHS) / sizeof(LHS)
+                // LHS minus RHS -> (LHS minus RHS) / sizeof(LHS)
                 if ( isPoly1 && isPoly2 ) {
-                        // There are only subtraction intrinsics for this pattern.
                         assert( "?-?" == varName );
-                        auto referentType = getReferentType( argType1 );
+                        assert( arg1Ty );
+                        auto arg1TyPtr = dynamic_cast<ast::PointerType const * >( arg1Ty );
+                        assert( arg1TyPtr );
                         auto divide = ast::UntypedExpr::createCall( location, "?/?", {
                                 expr,
-                                new ast::SizeofExpr( location, deepCopy( referentType ) ),
+                                new ast::SizeofExpr( location, deepCopy( arg1TyPtr->base ) ),
                         } );
                         if ( expr->env ) divide->env = expr->env;
@@ -1337 +1345 @@
                 // LHS op RHS -> LHS op (RHS * sizeof(LHS))
                 } else if ( isPoly1 ) {
-                        auto referentType = getReferentType( argType1 );
+                        assert( arg1Ty );
+                        auto arg1TyPtr = dynamic_cast<ast::PointerType const * >( arg1Ty );
+                        assert( arg1TyPtr );
                         auto multiply = ast::UntypedExpr::createCall( location2, "?*?", {
                                 expr->args.back(),
-                                new ast::SizeofExpr( location1, deepCopy( referentType ) ),
+                                new ast::SizeofExpr( location1, deepCopy( arg1TyPtr->base ) ),
                         } );
                         return ast::mutate_field_index(
@@ -1346 +1356 @@
                 // LHS op RHS -> (LHS * sizeof(RHS)) op RHS
                 } else if ( isPoly2 ) {
-                        auto referentType = getReferentType( argType2 );
+                        assert( arg2Ty );
+                        auto arg2TyPtr = dynamic_cast<ast::PointerType const * >( arg2Ty );
+                        assert( arg2TyPtr );
                         auto multiply = ast::UntypedExpr::createCall( location1, "?*?", {
                                 expr->args.front(),
-                                new ast::SizeofExpr( location2, deepCopy( referentType ) ),
+                                new ast::SizeofExpr( location2, deepCopy( arg2TyPtr->base ) ),
                         } );
                         return ast::mutate_field_index(
                                 expr, &ast::ApplicationExpr::args, 0, multiply );
                 }
-        // Addition and Subtraction Relative Assignment Intrinsics:
+        // Addition and Subtration Relative Assignment Intrinsics:
         } else if ( "?+=?" == varName || "?-=?" == varName ) {
                 assert( expr->result );