Changes in / [03606ce:169496e1]

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 ( auto type2AsPos = dynamic_cast<const ast::EnumPosType *>(type2) ) {
+                if ( dynamic_cast<const ast::EnumPosType *>(type2) ) {
                         // result = commonType( type2AsPos->instance, enumPos->instance, tenv, need, have, open, widen );
-                        // result = enumPos;
-                        if ( enumPos->instance->base->name == type2AsPos->instance->base->name ) {
-                                result = type2;
-                        }
+                        result = enumPos;
                 } 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;
-        } 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 {
+        } 
+        // 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 * posType ) {
+                void postvisit( const ast::EnumPosType * ) {
                         // Lazy approach for now
                         auto otherPos = dynamic_cast< const ast::EnumPosType *>(type2);
-                        if ( otherPos ) {
-                                if ( otherPos->instance->base->name == posType->instance->base->name )
-                                        result = otherPos;
-                        }
+                        if (otherPos) this->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 {
@@ -352 +416 @@
             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>()) {
@@ -429 +525 @@
     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
     ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
+    ast::Pass<ReplaceEnumInst>::run(translationUnit);
 
     ast::Pass<ReplaceSuccAndPred>::run(translationUnit);