Changeset bbf2cb1

Timestamp:

Mar 6, 2024, 6:06:30 AM (2 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

f6e8c67

Parents:

00eaeb8

Message:

Add the Working support to succ() and pred() pseudo function to Enum

Location:

src

Files:

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

src/ResolvExpr/CommonType.cc

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

src/ResolvExpr/ConversionCost.cc

@@ -366 +366 @@
 }
 
-void ConversionCost::postvisit( const ast::EnumInstType * ) {
+void ConversionCost::postvisit( const ast::EnumInstType * inst ) {
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
@@ -374 +374 @@
 }
 
-void ConversionCost::postvisit( const ast::EnumPosType * ) {
-        if ( dynamic_cast<const ast::EnumPosType *>( dst ) ) {
-                // Tempoarary
-                cost = Cost::zero;
-        } else {
+void ConversionCost::postvisit( const ast::EnumPosType * src ) {
+        if ( auto dstBase = dynamic_cast<const ast::EnumPosType *>( dst ) ) {
+                // cost = costCalc( src->instance, dstBase->instance, srcIsLvalue, symtab, env );
+                // 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 {
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );

src/ResolvExpr/Unify.cc

@@ -518 +518 @@
 
                 void postvisit( const ast::EnumPosType * ) {
-                        // Does nothing for now. Handled in ReplacePseudoFunc
-                        // Might move here in the future
+                        // Lazy approach for now
+                        auto otherPos = dynamic_cast< const ast::EnumPosType *>(type2);
+                        if (otherPos) this->result = otherPos;
                 }
 

src/Validate/Autogen.cpp

@@ -212 +212 @@
         ast::FunctionDecl * genPredPosProto() const;
 
-        void genSuccFunc(ast::FunctionDecl *);
+        ast::FunctionDecl * genSuccPredFunc( bool succ );
+        // ast::FunctionDecl * genPredFunc();
 };
 
@@ -811 +812 @@
 
 ast::FunctionDecl * EnumFuncGenerator::genSuccPosProto() const {
-        return genProto( "succ",
+        return genProto( "_successor_",
                 { new ast::ObjectDecl( getLocation(), "_i", 
                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
@@ -821 +822 @@
 
 ast::FunctionDecl * EnumFuncGenerator::genPredPosProto() const {
-        return genProto( "pred",
+        return genProto( "_predessor_",
                 { new ast::ObjectDecl( getLocation(), "_i", 
                         new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
@@ -830 +831 @@
 }
 
-void EnumFuncGenerator::genSuccFunc(ast::FunctionDecl * succDecl) {
+ast::FunctionDecl * EnumFuncGenerator::genSuccPredFunc( bool succ ) {
+        ast::FunctionDecl * decl = succ? genSuccPosProto(): genPredPosProto();
+        produceForwardDecl( decl );
+
         const CodeLocation& location = getLocation();
 
-        auto & params = succDecl->params;
+        auto & params = decl->params;
         assert( params.size() == 1 );
         auto param = params.front().strict_as<ast::ObjectDecl>();
-
-        // auto & returns = succDecl->returns;
-        // assert( returns.size() == 1 );
-        // auto oldRet = returns.front().strict_as<ast::ObjectDecl>();
-
-        // auto param = new ast::ObjectDecl( getLocation(), "_i", 
-        //              new ast::EnumPosType( new ast::EnumInstType( decl ) ) );
 
         auto newReturn = new ast::ObjectDecl( location, "_returns",
@@ -849 +846 @@
 
         ast::UntypedExpr * addOneExpr = new ast::UntypedExpr( location,
-                new ast::NameExpr( location, "?+?" )
+                new ast::NameExpr( location, succ? "?+?": "?-?" )
         );
         addOneExpr->args.push_back( 
@@ -871 +868 @@
         );
 
-        succDecl->stmts = new ast::CompoundStmt( location, 
+        decl->stmts = new ast::CompoundStmt( location, 
                 {
                         new ast::DeclStmt( location, newReturn ),
@@ -878 +875 @@
                                 new ast::VariableExpr( location, newReturn )) 
                 } );
+        
+        return decl;
 }
 
@@ -886 +885 @@
                         &EnumFuncGenerator::genValueProto, &EnumFuncGenerator::genSuccProto,
                         &EnumFuncGenerator::genPredProto
+                        // ,&EnumFuncGenerator::genSuccPosProto,
+                        // &EnumFuncGenerator::genPredPosProto
                 };
                 for ( auto & generator : attrProtos ) {
@@ -895 +896 @@
 void EnumFuncGenerator::genPosFunctions() {
         if ( decl->base ) {
-                ast::FunctionDecl * decl = genSuccPosProto();
-                produceForwardDecl( decl );
-                genSuccFunc (decl );
-                produceDecl( decl );
+                ast::FunctionDecl * succ = genSuccPredFunc( true );
+                ast::FunctionDecl * pred = genSuccPredFunc( false );
+                produceDecl( succ );
+                produceDecl( pred );
         }
 

src/Validate/ReplacePseudoFunc.cpp

@@ -21 +21 @@
 
 struct ReplaceEnumInstWithPos final : public ast::WithShortCircuiting {
-    void previsit(const ast::ObjectDecl*) { visit_children = false; }
     const ast::ObjectDecl* postvisit(const ast::ObjectDecl* decl) {
         auto enumInst = decl->type.strict_as<ast::EnumInstType>();
@@ -84 +83 @@
     }
 
-    if (fname == "labelE" || fname == "valueE" || fname == "posE") {
+    if (fname == "labelE" || fname == "valueE" || fname == "posE" ||
+        fname == "pred" || fname == "succ") {
         visit_children = false;
     }
@@ -226 +226 @@
 }
 
-ast::ApplicationExpr const* getPseudoFuncApplication(
+ast::ApplicationExpr const* resolveAttributeFunctions(
     const CodeLocation location, ResolvExpr::ResolveContext context,
     const ast::VariableExpr* arg, const ast::EnumDecl* base,
@@ -241 +241 @@
         auto rep = argAsDecl->accept(replacer);
         auto mutatedArg = ast::mutate_field(arg, &ast::VariableExpr::var, rep);
+        mutatedArg = ast::mutate_field(mutatedArg, &ast::VariableExpr::result,
+                                       mutatedArg->var->get_type());
         auto untyped =
             new ast::UntypedExpr(location, new ast::NameExpr(location, "?[?]"),
@@ -290 +292 @@
                                                               referredName);
                     else {
-                        return getPseudoFuncApplication(
+                        return resolveAttributeFunctions(
                             location, context, arg.get(), base, "values_");
                     }
@@ -297 +299 @@
 
             if (fname == "labelE") {
-                if (auto labelExpr = getPseudoFuncApplication(
+                if (auto labelExpr = resolveAttributeFunctions(
                         location, context, arg.get(), base, "labels_")) {
                     return labelExpr;
                 }
             } else if (fname == "valueE") {
-                if (auto valueExpr = getPseudoFuncApplication(
+                if (auto valueExpr = resolveAttributeFunctions(
                         location, context, arg.get(), base, "values_")) {
                     return valueExpr;
@@ -314 +316 @@
             ResolvExpr::ResolveContext context{symtab, transUnit().global};
             if (fname == "labelE") {
-                if (auto labelExpr = getPseudoFuncApplication(
+                if (auto labelExpr = resolveAttributeFunctions(
                         location, context, arg.get(), base, "labels_")) {
                     return labelExpr;
                 }
             } else if (fname == "valueE") {
-                if (auto valueExpr = getPseudoFuncApplication(
+                if (auto valueExpr = resolveAttributeFunctions(
                         location, context, arg.get(), base, "values_")) {
                     return valueExpr;
@@ -345 +347 @@
     const ast::Expr* postvisit(const ast::ApplicationExpr* expr) {
         auto fname = ast::getFunctionName(expr);
-        if (fname != "?[?]") return expr;
-        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 arg1Asecl = arg1AsVar->var.as<ast::ObjectDecl>();
-        auto arg2Asecl = arg2AsVar->var.as<ast::ObjectDecl>();
-
-        if (!arg1Asecl || !arg2Asecl) return expr;
-        auto arrInst = arg1Asecl->type.as<ast::ArrayType>();
-        auto pointerInst = arg1Asecl->type.as<ast::PointerType>();
-        if (!arrInst && !pointerInst) {
-            return expr;
-        }
-        auto enumInst = arg2Asecl->type.as<ast::EnumInstType>();
-        if (!enumInst) return expr;
-
-        const std::string arrName = arg1Asecl->name;
-        if (arrName != getValueArrayName(enumInst->base->name)) return expr;
-        ast::Pass<ReplaceEnumInstWithPos> replacer;
-        auto rep = arg2Asecl->accept(replacer);
-        if (!rep) return expr;
-        auto mutObj =
-            ast::mutate_field(arg2AsVar, &ast::VariableExpr::var, rep);
-        auto mut = ast::mutate_field_index(expr, &ast::ApplicationExpr::args, 1,
-                                           mutObj);
-        return mut;
+        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 {
+    const ast::Expr* postvisit(const ast::ApplicationExpr* expr) {
+        auto fname = ast::getFunctionName(expr);
+        if (fname == "succ" || fname == "pred") {
+            const CodeLocation& location = expr->location;
+            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>()) {
+                if (auto argAsDecl = argAsVar->var.as<ast::ObjectDecl>()) {
+                    if (auto enumInst =
+                            argAsDecl->type.as<ast::EnumInstType>()) {
+                        auto castTo = new ast::EnumPosType(enumInst);
+                        auto castExpr =
+                            new ast::CastExpr(param->location, param, castTo);
+
+                        auto untyped = new ast::UntypedExpr(
+                            expr->location,
+                            new ast::NameExpr(location, fname == "succ"
+                                                            ? "_successor_"
+                                                            : "_predessor_"),
+                            {castExpr});
+                        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);
+                    } else if (auto posType =
+                                   argAsDecl->type.as<ast::EnumPosType>()) {
+                        // Very nasty fix. Must be revisit
+                        if (auto paramAsVar = param.as<ast::VariableExpr>()) {
+                            if (paramAsVar->result.as<ast::EnumInstType>()) {
+                                auto paramToUse = ast::mutate_field(
+                                    paramAsVar, &ast::VariableExpr::result,
+                                    posType);
+                                auto untyped = new ast::UntypedExpr(
+                                    expr->location,
+                                    new ast::NameExpr(location,
+                                                      fname == "succ"
+                                                          ? "_successor_"
+                                                          : "_predessor_"),
+                                    {paramToUse});
+                                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 untyped = new ast::UntypedExpr(
+                            expr->location,
+                            new ast::NameExpr(location, fname == "succ"
+                                                            ? "_successor_"
+                                                            : "_predessor_"),
+                            {param});
+                        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);
+                    }
+                }
+            }
+        }
+        return expr;
     }
 };
@@ -385 +522 @@
     ast::Pass<WrapEnumValueExpr>::run(translationUnit);
     ast::Pass<FindGenEnumArray>::run(translationUnit);
+
     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
     ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
     ast::Pass<ReplaceEnumInst>::run(translationUnit);
+
+    ast::Pass<ReplaceSuccAndPred>::run(translationUnit);
 }
 }  // namespace Validate