Changes in src/Validate/ReplacePseudoFunc.cpp [c75b30a:544deb9]

File:

• src/Validate/ReplacePseudoFunc.cpp (modified) (8 diffs)

src/Validate/ReplacePseudoFunc.cpp

@@ -17 +17 @@
 std::set<std::string> queryValues;
 
-struct WrapEnumValueExpr final : public ast::WithShortCircuiting,
-                                 public ast::WithSymbolTable,
-                                 public ast::WithConstTranslationUnit {
-    void previsit(const ast::DeclStmt* expr);
-    void previsit(const ast::ApplicationExpr* expr);
-    void previsit(const ast::CastExpr* expr);
-
-    ast::Expr const* postvisit(const ast::VariableExpr* expr);
-};
-
 struct FindGenEnumArray final : public ast::WithShortCircuiting {
     void previsit(const ast::ApplicationExpr* enumDecl);
 };
-
-struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
-                                         public ast::WithSymbolTable,
-                                         public ast::WithShortCircuiting {
-    void previsit(const ast::EnumDecl* enumDecl);
-};
-
-struct ReplacePseudoFuncCore : public ast::WithShortCircuiting,
-                               public ast::WithSymbolTable,
-                               public ast::WithConstTranslationUnit {
-    ast::Expr const* postvisit(ast::ApplicationExpr const* decl);
-};
-
-void WrapEnumValueExpr::previsit(const ast::ApplicationExpr* expr) {
-
-    auto varExpr = expr->func.as<ast::VariableExpr>();
-    auto fname = ast::getFunctionName(expr);
-        if ( !varExpr || varExpr->var->linkage == ast::Linkage::Intrinsic ) {
-        if ( fname == "?{}" || fname == "?=?" )
-                    visit_children = false;
-        }
-
-    if (fname == "labelE" || fname == "valueE" || fname == "posE")
-        visit_children = false;
-}
-
-void WrapEnumValueExpr::previsit(const ast::DeclStmt*) {
-    visit_children = false;
-}
-
-void WrapEnumValueExpr::previsit(const ast::CastExpr* expr) {
-    if (expr->result && expr->result.as<ast::ReferenceType>()) {
-        visit_children = false;
-    }
-}
-
-ast::Expr const* WrapEnumValueExpr::postvisit(const ast::VariableExpr* expr) {
-    visit_children = false;
-    if (!expr->result) {
-        return expr;
-    }
-    if (auto enumInst = expr->result.as<ast::EnumInstType>()) {
-        if (enumInst->base && enumInst->base->base) {
-            auto untyped = new ast::UntypedExpr(
-                expr->location, new ast::NameExpr(expr->location, "valueE"),
-                {new ast::VariableExpr(*expr)});
-            ResolvExpr::ResolveContext context{symtab, transUnit().global};
-            auto result = ResolvExpr::findVoidExpression(untyped, context);
-            if (result.get()) {
-                ast::ptr<ast::ApplicationExpr> ret =
-                    result.strict_as<ast::ApplicationExpr>();
-                return new ast::ApplicationExpr(*ret);
-            }
-        }
-    }
-    return expr;
-}
 
 void FindGenEnumArray::previsit(const ast::ApplicationExpr* expr) {
@@ -115 +48 @@
 }
 
+struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
+                                         public ast::WithSymbolTable,
+                                         public ast::WithShortCircuiting {
+    void previsit(const ast::EnumDecl* enumDecl);
+};
+
 void PseudoFuncGenerateRoutine::previsit(const ast::EnumDecl* enumDecl) {
     visit_children = false;
@@ -128 +67 @@
             location, ast::ConstantExpr::from_string(location, mem->name)));
     }
-    // Values only
     if (queryValues.count(enumDecl->name)) {
         auto init = new ast::ListInit(location, std::move(inits));
-        const ast::ArrayType* arrT = new ast::ArrayType(
-            enumDecl->base,
-            ast::ConstantExpr::from_int(location, enumDecl->members.size()),
-            ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim);
-        ast::ObjectDecl* values = new ast::ObjectDecl(
-            location, "values_" + enumDecl->name, arrT, init,
-            ast::Storage::Static, ast::Linkage::AutoGen);
+        auto values = new ast::ObjectDecl(
+            location, "values_" + enumDecl->name,
+            new ast::ArrayType(
+                enumDecl->base,
+                ast::ConstantExpr::from_int(location, enumDecl->members.size()),
+                ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim),
+            init, ast::Storage::Static, ast::Linkage::AutoGen);
         symtab.addId(values);
         values->mangleName = Mangle::mangle(values);
@@ -144 +82 @@
     if (queryLabels.count(enumDecl->name)) {
         auto label_strings = new ast::ListInit(location, std::move(labels));
-        auto labels = new ast::ObjectDecl(
+        auto label_arr = new ast::ObjectDecl(
             location, "labels_" + enumDecl->name,
             new ast::ArrayType(
@@ -151 +89 @@
                 ast::LengthFlag::FixedLen, ast::DimensionFlag::DynamicDim),
             label_strings, ast::Storage::Static, ast::Linkage::AutoGen);
-        symtab.addId(labels);
-        labels->mangleName = Mangle::mangle(labels);
-        declsToAddAfter.push_back(labels);
+        symtab.addId(label_arr);
+        label_arr->mangleName = Mangle::mangle(label_arr);
+        declsToAddAfter.push_back(label_arr);
     }
 }
 
-ast::ApplicationExpr const* getPseudoFuncApplication(
-    const CodeLocation location, ResolvExpr::ResolveContext context,
-    const ast::VariableExpr* arg, const ast::EnumDecl* base, const std::string & name) {
-    ast::Expr* toResolve = new ast::NameExpr(location, name + base->name);
-    auto result = ResolvExpr::findVoidExpression(toResolve, context);
-    assert(result.get());
-    auto arrAsVar = result.strict_as<ast::VariableExpr>();
-    auto untyped = new ast::UntypedExpr(
-        location, new ast::NameExpr(location, "?[?]"),
-        {new ast::VariableExpr(*arrAsVar), new ast::VariableExpr(*arg)});
-    auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
-
-    ast::ptr<ast::ApplicationExpr> ret =
-        typedResult.strict_as<ast::ApplicationExpr>();
-    return ast::deepCopy(ret);
-}
+struct ReplacePseudoFuncCore : public ast::WithShortCircuiting,
+                               public ast::WithSymbolTable,
+                               public ast::WithConstTranslationUnit {
+    ast::Expr const* postvisit(ast::ApplicationExpr const* decl);
+};
 
 ast::Expr const* ReplacePseudoFuncCore::postvisit(
@@ -198 +125 @@
         }
         const ast::EnumDecl* base = argType->base;
-        ResolvExpr::ResolveContext context{symtab, transUnit().global};
-        // If resolvable as constant
         for (size_t i = 0; i < base->members.size(); i++) {
             if (base->members[i]->name == referredName) {
@@ -208 +133 @@
                                                           referredName);
                 else
-                    return getPseudoFuncApplication(location, context, arg.get(),
-                                               base, "values_");
+                    return new ast::TypeExpr(expr->location, argType);
             }
         }
 
+        ResolvExpr::ResolveContext context{symtab, transUnit().global};
+
         if (fname == "labelE") {
-            if (auto labelExpr =
-                    getPseudoFuncApplication(location, context, arg.get(), base, "labels_")) {
-                return labelExpr;
+            ast::Expr* toResolve =
+                new ast::NameExpr(expr->location, "labels_" + base->name);
+            auto result = ResolvExpr::findVoidExpression(toResolve, context);
+            if (result.get()) {
+                auto arrAsVar = result.strict_as<ast::VariableExpr>();
+                auto untyped = new ast::UntypedExpr(
+                    location, new ast::NameExpr(location, "?[?]"),
+                    {new ast::VariableExpr(*arrAsVar),
+                     ast::ConstantExpr::from_int(
+                         location,
+                         0)});  /// TODO: dummy value.
+                                /// To make it works need to change the unifier
+
+                auto typedResult =
+                    ResolvExpr::findVoidExpression(untyped, context);
+                if (result.get()) {
+                    ast::ptr<ast::ApplicationExpr> ret =
+                        typedResult.strict_as<ast::ApplicationExpr>();
+                    return new ast::ApplicationExpr(*ret);
+                }
             }
-        } else if (fname == "valueE") {
-            if (auto valueExpr =
-                    getPseudoFuncApplication(location, context, arg.get(), base, "values_")) {
-                return valueExpr;
+        }
+        
+        if (fname == "valueE") {
+            ast::Expr* toResolve =
+                new ast::NameExpr(expr->location, "values_" + base->name);
+            auto result = ResolvExpr::findVoidExpression(toResolve, context);
+            if (result.get()) {
+                auto arrAsVar = result.strict_as<ast::VariableExpr>();
+                auto untyped = new ast::UntypedExpr(
+                    location, new ast::NameExpr(location, "?[?]"),
+                    {new ast::VariableExpr(*arrAsVar),
+                     ast::ConstantExpr::from_int(
+                         location,
+                         0)});  /// TODO: dummy value.
+                                /// To make it works need to change the unifier
+
+                auto typedResult =
+                    ResolvExpr::findVoidExpression(untyped, context);
+                if (result.get()) {
+                    ast::ptr<ast::ApplicationExpr> ret =
+                        typedResult.strict_as<ast::ApplicationExpr>();
+                    return new ast::ApplicationExpr(*ret);
+                }
             }
-        } else { // it is position; replace itself
-            return std::move( arg.get() );
         }
     }
@@ -233 +193 @@
 
 void replacePseudoFunc(ast::TranslationUnit& translationUnit) {
-    ast::Pass<WrapEnumValueExpr>::run(translationUnit);
     ast::Pass<FindGenEnumArray>::run(translationUnit);
     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);