Changes in / [169496e1:03606ce]

Location:

src

Files:

• ResolvExpr/CommonType.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• ResolvExpr/Unify.cc (modified) (1 diff)
• Validate/ReplacePseudoFunc.cpp (modified) (3 diffs)

src/ResolvExpr/CommonType.cc

@@ -681 +681 @@
 
         void postvisit( const ast::EnumPosType * enumPos ) {
-                if ( dynamic_cast<const ast::EnumPosType *>(type2) ) {
+                if ( auto type2AsPos = dynamic_cast<const ast::EnumPosType *>(type2) ) {
                         // result = commonType( type2AsPos->instance, enumPos->instance, tenv, need, have, open, widen );
-                        result = enumPos;
+                        // result = enumPos;
+                        if ( enumPos->instance->base->name == type2AsPos->instance->base->name ) {
+                                result = type2;
+                        }
                 } else if ( dynamic_cast<const ast::BasicType *>(type2) ) {
                         result = type2;

src/ResolvExpr/ConversionCost.cc

@@ -379 +379 @@
                 // if ( cost < Cost::unsafe ) cost.incSafe();
                 cost = Cost::zero;
-        } 
-        // if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-        //      cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
-        //      if ( cost < Cost::unsafe ) cost.incSafe();
-        // } 
-        else {
+        } else if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
+                cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
+                if ( cost < Cost::unsafe ) cost.incSafe();
+        } else {
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );

src/ResolvExpr/Unify.cc

@@ -517 +517 @@
                 }
 
-                void postvisit( const ast::EnumPosType * ) {
+                void postvisit( const ast::EnumPosType * posType ) {
                         // Lazy approach for now
                         auto otherPos = dynamic_cast< const ast::EnumPosType *>(type2);
-                        if (otherPos) this->result = otherPos;
+                        if ( otherPos ) {
+                                if ( otherPos->instance->base->name == posType->instance->base->name )
+                                        result = otherPos;
+                        }
                 }
 

src/Validate/ReplacePseudoFunc.cpp

@@ -344 +344 @@
 }
 
-struct ReplaceEnumInst final {
-    const ast::Expr* postvisit(const ast::ApplicationExpr* expr) {
-        auto fname = ast::getFunctionName(expr);
-        if (fname == "?[?]") {
-            if (expr->args.size() != 2) return expr;
-
-            auto arg1AsVar =
-                reduceCastExpr(expr->args.front()).as<ast::VariableExpr>();
-            auto arg2AsVar =
-                reduceCastExpr(expr->args.back()).as<ast::VariableExpr>();
-
-            if (!arg1AsVar || !arg2AsVar) return expr;
-
-            auto arg1AsDecl = arg1AsVar->var.as<ast::ObjectDecl>();
-            auto arg2AsDecl = arg2AsVar->var.as<ast::ObjectDecl>();
-
-            if (!arg1AsDecl || !arg2AsDecl) return expr;
-            auto arrInst = arg1AsDecl->type.as<ast::ArrayType>();
-            auto pointerInst = arg1AsDecl->type.as<ast::PointerType>();
-            if (!arrInst && !pointerInst) {
-                return expr;
-            }
-            auto enumInst = arg2AsDecl->type.as<ast::EnumInstType>();
-            if (!enumInst) return expr;
-
-            const std::string arrName = arg1AsDecl->name;
-            if (arrName != getValueArrayName(enumInst->base->name)) return expr;
-            ast::Pass<ReplaceEnumInstWithPos> replacer;
-            auto rep = arg2AsDecl->accept(replacer);
-            if (!rep) return expr;
-            auto mutObj =
-                ast::mutate_field(arg2AsVar, &ast::VariableExpr::var, rep);
-            mutObj = ast::mutate_field(mutObj, &ast::VariableExpr::result,
-                                       mutObj->var->get_type());
-            auto mut = ast::mutate_field_index(
-                expr, &ast::ApplicationExpr::args, 1, mutObj);
-            return mut;
-        }
-        // else if (fname == "succ" || fname == "pred") {
-        //     if (expr->args.size() != 1) return expr;
-        //     auto argExpr = expr->args.front();
-        //     auto argAsVar = reduceCastExpr(argExpr).as<ast::VariableExpr>();
-
-        //     if (auto argAsDecl = argAsVar->var.as<ast::ObjectDecl>()) {
-        //         if (auto enumInst = argAsDecl->type.as<ast::EnumInstType>())
-        //         {
-        //             auto enumPos = new ast::EnumPosType(enumInst);
-        //             auto castExpr =
-        //                 new ast::CastExpr(argExpr->location, argExpr,
-        //                 enumPos);
-        //             auto mut = ast::mutate_field_index(
-        //                 expr, &ast::ApplicationExpr::args, 0, castExpr);
-        //             return mut;
-        //         } else if (auto enumPos =
-        //                        argAsDecl->type.as<ast::EnumPosType>()) {
-        //             //     std::cout << "pos" << std::endl;
-        //             return expr;
-        //         }
-        //     }
-        // }
-        return expr;
-    }
-};
-
 struct ReplaceSuccAndPred final : public ast::WithSymbolTable,
                                   public ast::WithConstTranslationUnit {
@@ -416 +352 @@
             if (expr->args.size() != 1) return expr;
 
-            // if (auto argAsVar = reduceCastExpr(expr->args.front())
-            //                         .as<ast::VariableExpr>()) {
-            //     if (auto argAsDecl = argAsVar->var.as<ast::ObjectDecl>()) {
-            //         auto enumPos = argAsDecl->type.as<ast::EnumPosType>();
-            //         if (!enumPos) return expr;
-            //         // ast::Pass<ReplaceEnumInstWithPos> replacer;
-            //         // auto posObj = argAsDecl->accept(replacer);
-            //         // if (!posObj) return expr;
-
-            //         // auto newParam = new ast::VariableExpr( location,
-            //         posObj
-            //         // );
-
-            //         auto untyped = new ast::UntypedExpr(
-            //             location,
-            //             new ast::NameExpr(location, fname == "succ"
-            //                                             ? "_successor_"
-            //                                             : "_predessor_"),
-            //             {argAsVar});
-
-            //         ResolvExpr::ResolveContext context{symtab,
-            //                                            transUnit().global};
-
-            //         auto typedResult =
-            //             ResolvExpr::findVoidExpression(untyped, context);
-
-            //         ast::ptr<ast::ApplicationExpr> ret =
-            //             typedResult.strict_as<ast::ApplicationExpr>();
-
-            //         return ast::deepCopy(ret);
-            //     }
-            // }
             auto param = expr->args.front();
             if (auto argAsVar = reduceCastExpr(param).as<ast::VariableExpr>()) {
@@ -525 +429 @@
     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
     ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
-    ast::Pass<ReplaceEnumInst>::run(translationUnit);
 
     ast::Pass<ReplaceSuccAndPred>::run(translationUnit);