Changes in / [7552fde:55ba259e]

Location:

src

Files:

• AST/Stmt.hpp (modified) (2 diffs)
• ControlStruct/TranslateEnumRange.cpp (modified) (3 diffs)
• Parser/StatementNode.cpp (modified) (1 diff)
• Parser/StatementNode.hpp (modified) (2 diffs)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• ResolvExpr/CastCost.cpp (modified) (1 diff)
• ResolvExpr/ConversionCost.cpp (modified) (4 diffs)
• ResolvExpr/Unify.cpp (modified) (5 diffs)

src/AST/Stmt.hpp

@@ -238 +238 @@
         ptr<Expr> inc;
         ptr<Expr> range_over;
-        bool is_inc;
         ptr<Stmt> body;
         ptr<Stmt> else_;
@@ -252 +251 @@
                         range_over(nullptr), body(body), else_(else_) {}
 
-        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, bool is_inc,
+        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * range_over, 
                          const Stmt * body, const Stmt * else_ )
-                : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), is_inc(is_inc), 
-                body(body), else_(else_) {}
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), range_over(range_over), body(body), else_(else_) {}
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }

src/ControlStruct/TranslateEnumRange.cpp

@@ -26 +26 @@
         auto enumDecl = enumInst->base;
 
-        auto objInit = stmt->inits.front();
+        auto init = stmt->inits.front();
 
-        auto initLocation = objInit->location;
-        auto rangeLocation = stmt->range_over->location;
-        assert( stmt->inits.size() == 1 );
-
-        if (auto declStmt = objInit.as<ast::DeclStmt>()) {
+        if (auto declStmt = init.as<ast::DeclStmt>()) {
             auto decl = declStmt->decl;
             if ( auto objDecl = decl.as<ast::ObjectDecl>()) {
@@ -61 +57 @@
                 if ( !objDecl->init ) {
                     auto location = stmt->location;
-                    ast::SingleInit * newInit;
-                    newInit = new ast::SingleInit( location, 
-                        new ast::NameExpr( location, 
-                        stmt->is_inc? enumDecl->members.front()->name: enumDecl->members.back()->name ) );
+                    auto newInit = new ast::SingleInit( location, new ast::NameExpr( location, enumDecl->members.front()->name ) );
                     auto objDeclWithInit = ast::mutate_field( objDecl, &ast::ObjectDecl::init, newInit );
                     auto declWithInit = ast::mutate_field( declStmt, &ast::DeclStmt::decl, objDeclWithInit );
@@ -85 +78 @@
     auto enumInst = typeExpr->type.strict_as<ast::EnumInstType>();
     auto enumDecl = enumInst->base;
-    
-    // Both inc and dec check if the current posn less than the number of enumerator
-    // for dec, it keeps call pred until it passes 0 (the first enumerator) and underflow,
-    // it wraps around and become unsigned max
-    ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
-        "?<=?",
-        { 
-            ast::UntypedExpr::createCall(location, "posn", { new ast::NameExpr( location, indexName ) } ),
-            ast::ConstantExpr::from_ulong( location, enumDecl->members.size()-1 )
-        });
-    auto increment = ast::UntypedExpr::createCall( location, 
-        stmt->is_inc? "succ": "pred",
-        { new ast::NameExpr( location, indexName ) });
+
+    auto condition = ast::UntypedExpr::createCall( location, "?<=?", {
+        new ast::NameExpr( location, indexName ),
+        // ast::ConstantExpr::from_ulong( location, enumDecl->members.size() )
+        new ast::NameExpr( location, enumDecl->members.back()->name )
+    });
+    auto increment = ast::UntypedExpr::createCall( location, "succ", {
+        new ast::NameExpr( location, indexName )
+    });
     auto assig = ast::UntypedExpr::createAssign( location, new ast::NameExpr( location, indexName ), increment );
     auto mut = ast::mutate_field( stmt, &ast::ForStmt::cond, condition );

src/Parser/StatementNode.cpp

@@ -216 +216 @@
                 return new ast::ForStmt( location,
                         std::move( astinit ),
-                        range_over, forctl->kind == OperKinds::LThan,
+                        range_over,
                         buildMoveSingle( stmt ),
                         buildMoveOptional( else_ )

src/Parser/StatementNode.hpp

@@ -64 +64 @@
         ForCtrl( StatementNode * stmt, ExpressionNode * condition, ExpressionNode * change ) :
                 init( stmt ), condition( condition ), change( change ), range_over( nullptr ) {}
-        ForCtrl( StatementNode * decl, ExpressionNode * range_over, OperKinds kind ) :
-                init( decl ), condition( nullptr ), change( nullptr ),  range_over( range_over ), kind( kind ) {}
+        ForCtrl( StatementNode * decl, ExpressionNode * _range_over) :
+                init( decl ), condition( nullptr ), change( nullptr ),  range_over( _range_over ) {}
 
         StatementNode * init;
@@ -71 +71 @@
         ExpressionNode * change;
         ExpressionNode * range_over;
-        OperKinds kind;
 };
 

src/Parser/parser.yy

@@ -279 +279 @@
                 DeclarationNode * indexDecl = DeclarationNode::newName( new std::string(identifier->name) );
                 assert( range_over_expr );
-                return new ForCtrl( new StatementNode( indexDecl ), range_over_expr, compop );
+                return new ForCtrl( new StatementNode( indexDecl ), range_over_expr );
         } else {
                 SemanticError( yylloc, MISSING_LOOP_INDEX ); return nullptr;

src/ResolvExpr/CandidateFinder.cpp

@@ -698 +698 @@
                 void postvisit( const ast::CountExpr * countExpr );
 
+                const ast::Expr * makeEnumOffsetCast( const ast::EnumInstType * src, 
+                        const ast::EnumInstType * dst
+                        , const ast::Expr * expr, Cost minCost );
+
                 void postvisit( const ast::InitExpr * ) {
                         assertf( false, "CandidateFinder should never see a resolved InitExpr." );
@@ -1209 +1213 @@
         }
 
+        // src is a subset of dst
+        const ast::Expr * Finder::makeEnumOffsetCast( const ast::EnumInstType * src, 
+                const ast::EnumInstType * dst,
+                const ast::Expr * expr,
+                Cost minCost ) {
+                
+                auto srcDecl = src->base;
+                auto dstDecl = dst->base;
+
+                if (srcDecl->name == dstDecl->name) return expr;
+
+                for (auto& dstChild: dstDecl->inlinedDecl) {
+                        Cost c = castCost(src, dstChild, false, symtab, tenv);
+                        ast::CastExpr * castToDst;
+                        if (c<minCost) {
+                                unsigned offset = dstDecl->calChildOffset(dstChild.get());
+                                if (offset > 0) {
+                                        auto untyped = ast::UntypedExpr::createCall(
+                                                expr->location, 
+                                                "?+?", 
+                                                { new ast::CastExpr( expr, new ast::BasicType(ast::BasicKind::SignedInt) ),
+                                                ast::ConstantExpr::from_int(expr->location, offset)});
+                                        CandidateFinder finder(context, tenv);
+                                        finder.find( untyped );
+                                        CandidateList winners = findMinCost( finder.candidates );
+                                        CandidateRef & choice = winners.front();
+                                        // choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
+                                        choice->expr = new ast::CastExpr(expr->location, choice->expr, dstChild, ast::GeneratedFlag::ExplicitCast);
+                                        // castToDst = new ast::CastExpr(choice->expr, dstChild);
+                                        castToDst = new ast::CastExpr( 
+                                                makeEnumOffsetCast( src, dstChild, choice->expr, minCost ),
+                                         dst);
+
+                                } else {
+                                        castToDst = new ast::CastExpr( expr, dst );
+                                }
+                                return castToDst;
+                        }
+                }
+                SemanticError(expr, src->base->name + " is not a subtype of " + dst->base->name);
+                return nullptr;
+        }
+
         void Finder::postvisit( const ast::CastExpr * castExpr ) {
                 ast::ptr< ast::Type > toType = castExpr->result;
@@ -1262 +1309 @@
                         auto argAsEnum = cand->expr->result.as<ast::EnumInstType>();
                         auto toAsEnum = toType.as<ast::EnumInstType>();
-                        if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {
-                                CandidateFinder subFinder(context, tenv);
-                                ast::ptr<ast::Expr> offsetExpr = subFinder.makeEnumOffsetCast(argAsEnum, toAsEnum, cand->expr, thisCost);
+                        if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {     
+                                ast::ptr<ast::Expr> offsetExpr = makeEnumOffsetCast(argAsEnum, toAsEnum, cand->expr, thisCost);
                                 cand->expr = offsetExpr;
                         }
@@ -2147 +2193 @@
                                         expr->location, 
                                         "?+?", 
-                                        { new ast::CastExpr( expr->location,
-                                                expr,
-                                                new ast::BasicType(ast::BasicKind::SignedInt),
-                                                ast::GeneratedFlag::ExplicitCast ),
-                                                ast::ConstantExpr::from_int(expr->location, offset)} );
+                                        { new ast::CastExpr( expr, new ast::BasicType(ast::BasicKind::SignedInt) ),
+                                        ast::ConstantExpr::from_int(expr->location, offset)});
                                 CandidateFinder finder(context, env);
                                 finder.find( untyped );

src/ResolvExpr/CastCost.cpp

@@ -53 +53 @@
                 void postvisit( const ast::EnumInstType * enumInst ) {
                         cost = conversionCost( enumInst, dst, srcIsLvalue, symtab, env );
-
-                        if (Cost::unsafe < cost) {
-                                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                                Cost intCost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-                                cost = intCost < cost? intCost: cost;
-                        }
-                        if ( enumInst->base->isTyped && enumInst->base->base ) {
-                                auto baseConversionCost = 
-                                        castCost( enumInst->base->base, dst, srcIsLvalue, symtab, env );
-                                cost = baseConversionCost < cost? baseConversionCost: cost;
-                        }
                 }
 

src/ResolvExpr/ConversionCost.cpp

@@ -162 +162 @@
 Cost conversionCost(
         const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -284 +284 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
@@ -368 +368 @@
                 return;
         }
-
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         if ( !inst->base->isTyped ) {
-                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
                 if ( cost < Cost::unsafe ) {
                         cost.incSafe();
@@ -377 +376 @@
                 return;
         }
-        // cost.incUnsafe();
+        cost.incUnsafe();
 }
 

src/ResolvExpr/Unify.cpp

@@ -276 +276 @@
         void postvisit( const ast::VoidType * ) {
                 result = dynamic_cast< const ast::VoidType * >( type2 );
+                        // || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
+                ;
         }
 
@@ -282 +284 @@
                         result = basic->kind == basic2->kind;
                 }
+                // result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
         }
 
@@ -290 +293 @@
                                 noWiden());
                 }
+                // result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
         }
 
@@ -308 +312 @@
                 result = unifyExact(
                         array->base, array2->base, tenv, need, have, open, noWiden());
+                        // || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
         }
 
@@ -602 +607 @@
 
                 result = unifyList( types, types2, tenv, need, have, open );
+                        // || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::VarArgsType * ) {
                 result = dynamic_cast< const ast::VarArgsType * >( type2 );
+                        // || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::ZeroType * ) {
                 result = dynamic_cast< const ast::ZeroType * >( type2 );
+                        // || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::OneType * ) {
                 result = dynamic_cast< const ast::OneType * >( type2 );
+                        // || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
         }
 };