Add explicit METHOD to SOLVE if solving DERIVATIVE

Author: Goran Jelic-Cizmek

src/nmodl/main.cpp

@@ -30,6 +30,7 @@
 #include "visitors/global_var_visitor.hpp"
 #include "visitors/initial_block_visitor.hpp"
 #include "visitors/implicit_argument_visitor.hpp"
+#include "visitors/implicit_method_visitor.hpp"
 #include "visitors/indexedname_visitor.hpp"
 #include "visitors/inline_visitor.hpp"
 #include "visitors/json_visitor.hpp"
@@ -453,6 +454,12 @@ int run_nmodl(int argc, const char* argv[]) {
             SymtabVisitor(update_symtab).visit_program(*ast);
         }
 
+        /// insert an explicit method to SOLVE blocks (if required)
+        {
+            logger->info("Running implicit method for SOLVE block visitor");
+            ImplicitMethodVisitor().visit_program(*ast);
+            ast_to_nmodl(*ast, filepath("implicit_solve_method"));
+        }
 
         /// note that we can not symtab visitor in update mode as we
         /// replace kinetic block with derivative block of same name

src/nmodl/visitors/CMakeLists.txt

@@ -16,6 +16,7 @@ add_library(
   function_callpath_visitor.cpp
   global_var_visitor.cpp
   implicit_argument_visitor.cpp
+  implicit_method_visitor.cpp
   indexedname_visitor.cpp
   index_remover.cpp
   inline_visitor.cpp

src/nmodl/visitors/implicit_method_visitor.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2025 EPFL.
+ * See the top-level LICENSE file for details.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "ast/ast_decl.hpp"
+#include "ast/derivative_block.hpp"
+#include "ast/name.hpp"
+#include "ast/program.hpp"
+#include "ast/solve_block.hpp"
+#include "ast/string.hpp"
+#include "codegen/codegen_naming.hpp"
+#include "visitors/implicit_method_visitor.hpp"
+#include "visitors/visitor_utils.hpp"
+
+namespace nmodl {
+namespace visitor {
+
+void ImplicitMethodVisitor::visit_program(ast::Program& node) {
+    const auto& derivative_blocks = collect_nodes(node, {ast::AstNodeType::DERIVATIVE_BLOCK});
+    for (const auto& derivative_block: derivative_blocks) {
+        const auto& block = std::dynamic_pointer_cast<ast::DerivativeBlock>(derivative_block);
+        derivative_block_names.insert(block->get_node_name());
+    }
+    node.visit_children(*this);
+}
+
+void ImplicitMethodVisitor::visit_solve_block(ast::SolveBlock& node) {
+    const auto& name = node.get_block_name()->get_node_name();
+    const auto& method = node.get_method();
+    for (const auto& derivative_block_name: derivative_block_names) {
+        if (derivative_block_name == name && !method) {
+            node.set_method(std::make_shared<ast::Name>(
+                std::make_shared<ast::String>((codegen::naming::DERIVIMPLICIT_METHOD))));
+        }
+    }
+    node.visit_children(*this);
+}
+
+}  // namespace visitor
+}  // namespace nmodl

src/nmodl/visitors/implicit_method_visitor.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2025 EPFL.
+ * See the top-level LICENSE file for details.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+/**
+ * \file
+ * \brief \copybrief nmodl::visitor::ImplicitMethodVisitor
+ */
+
+#include "visitors/ast_visitor.hpp"
+
+#include <string>
+#include <unordered_set>
+
+
+namespace nmodl {
+namespace visitor {
+
+/**
+ * \addtogroup visitor_classes
+ * \{
+ */
+
+/**
+ * \class ImplicitMethodVisitor
+ * \brief %Visitor for adding implicit method to SOLVE blocks
+ */
+class ImplicitMethodVisitor: public AstVisitor {
+  private:
+    std::unordered_set<std::string> derivative_block_names;
+
+  public:
+    void visit_program(ast::Program& node) override;
+    void visit_solve_block(ast::SolveBlock& node) override;
+};
+
+/** \} */  // end of visitor_classes
+
+}  // namespace visitor
+}  // namespace nmodl

test/nmodl/transpiler/unit/CMakeLists.txt

@@ -47,6 +47,7 @@ add_executable(
   visitor/defuse_analyze.cpp
   visitor/global_to_range.cpp
   visitor/implicit_argument.cpp
+  visitor/implicit_method.cpp
   visitor/inline.cpp
   visitor/initial_block.cpp
   visitor/json.cpp

test/nmodl/transpiler/unit/visitor/implicit_method.cpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2023 Blue Brain Project, EPFL.
+ * See the top-level LICENSE file for details.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "ast/program.hpp"
+#include "parser/nmodl_driver.hpp"
+#include "utils/test_utils.hpp"
+#include "visitors/implicit_method_visitor.hpp"
+#include "visitors/nmodl_visitor.hpp"
+#include "visitors/symtab_visitor.hpp"
+#include "visitors/visitor_utils.hpp"
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+
+using namespace nmodl;
+using nmodl::test_utils::reindent_text;
+
+using Catch::Matchers::ContainsSubstring;  // ContainsSubstring in newer Catch2
+
+//=============================================================================
+// Implicit visitor tests
+//=============================================================================
+
+std::string generate_mod_after_implicit_method_visitor(std::string const& text) {
+    parser::NmodlDriver driver{};
+    auto const ast = driver.parse_string(text);
+    visitor::SymtabVisitor{}.visit_program(*ast);
+    visitor::ImplicitMethodVisitor{}.visit_program(*ast);
+    return to_nmodl(*ast);
+}
+
+SCENARIO("Check insertion of explicit arguments to SOLVE block", "[codegen][implicit_methods]") {
+    GIVEN("A mod file that has a SOLVE block of a derivative without an explicit METHOD") {
+        auto const nmodl_text = R"(
+            NEURON {
+                SUFFIX ImplicitMethodTest
+            }
+
+            BREAKPOINT {
+                SOLVE states
+            }
+
+            ASSIGNED {
+                n
+            }
+
+            DERIVATIVE states {
+                n' = -n
+            }
+        )";
+        auto const expected_text = R"(
+            NEURON {
+                SUFFIX ImplicitMethodTest
+            }
+
+            BREAKPOINT {
+                SOLVE states METHOD derivimplicit
+            }
+
+            ASSIGNED {
+                n
+            }
+
+            DERIVATIVE states {
+                n' = -n
+            }
+        )";
+        auto const actual_text = generate_mod_after_implicit_method_visitor(nmodl_text);
+        THEN("at_time should have nt as its first argument") {
+            REQUIRE(reindent_text(actual_text) == reindent_text(expected_text));
+        }
+    }
+}