Improve gorilla mux route extraction (#1779)

Author: hahwul

spec/functional_test/fixtures/go/mux/server.go

@@ -56,7 +56,7 @@ func main() {
 
 	// Static file serving
 	r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir("./static/"))))
-	
+
 	// Test multi-line route definition
 	r.HandleFunc(
 		"/multiline",
@@ -65,5 +65,18 @@ func main() {
 		},
 	).Methods("GET")
 
+	// Handler route and route-builder chains common in larger mux apps
+	r.Handle("/handler-route", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "handler route")
+	})).Methods("POST").Name("handler.create")
+
+	r.Methods("PATCH").Path("/builder-route").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "builder route")
+	})
+
+	r.Path("/builder-query").Methods("GET").Queries("type", "{type}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "builder query")
+	})
+
 	http.ListenAndServe(":8080", r)
-}
+}

spec/functional_test/fixtures/go/mux_callees/main.go

@@ -13,5 +13,13 @@ func main() {
 		w.Write([]byte("ok"))
 	}).Methods("GET")
 	r.HandleFunc("/profile", listProfile).Methods("GET")
+	r.Methods("POST").
+		Path("/builder-users").
+		HandlerFunc(createUser)
+	r.Path("/builder-healthz").
+		Methods("GET").
+		Handler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			w.Write([]byte("builder-ok"))
+		}))
 	http.ListenAndServe(":8080", r)
 }

spec/functional_test/testers/go/mux_callees_spec.cr

@@ -13,6 +13,10 @@ require "../../func_spec.cr"
 #   - GET /healthz  — same chain shape with an inline closure handler
 #                     in main.go.
 #   - GET /profile  — second named handler in handlers.go.
+#   - POST /builder-users
+#                   — builder chain with named handler in handlers.go.
+#   - GET /builder-healthz
+#                   — builder chain with http.HandlerFunc inline handler.
 helpers_path = "./spec/functional_test/fixtures/go/mux_callees/helpers.go"
 
 expected_endpoints = [
@@ -32,6 +36,17 @@ expected_endpoints = [
     ep.push_callee(Callee.new("auditLog", helpers_path, 7))
     ep.push_callee(Callee.new("w.Write", line: 17))
   end,
+
+  Endpoint.new("/builder-users", "POST").tap do |ep|
+    ep.push_callee(Callee.new("r.FormValue"))
+    ep.push_callee(Callee.new("saveUser"))
+    ep.push_callee(Callee.new("auditLog"))
+    ep.push_callee(Callee.new("w.Write"))
+  end,
+
+  Endpoint.new("/builder-healthz", "GET").tap do |ep|
+    ep.push_callee(Callee.new("w.Write"))
+  end,
 ]
 
 FunctionalTester.new("fixtures/go/mux_callees/", {

spec/functional_test/testers/go/mux_spec.cr

@@ -24,6 +24,11 @@ expected_endpoints = [
   Endpoint.new("/api/v1/health", "GET"),
   Endpoint.new("/static/test.txt", "GET"),
   Endpoint.new("/multiline", "GET"),
+  Endpoint.new("/handler-route", "POST"),
+  Endpoint.new("/builder-route", "PATCH"),
+  Endpoint.new("/builder-query", "GET", [
+    Param.new("type", "", "query"),
+  ]),
   # handlers.go: PUT method with path variable
   Endpoint.new("/items/{id}", "PUT", [
     Param.new("id", "", "path"),

spec/unit_test/miniparser/go_callee_extractor_spec.cr

@@ -208,5 +208,59 @@ describe Noir::GoCalleeExtractor do
       names.should contain("lookupUser")
       names.should contain("c.JSON")
     end
+
+    it "resolves mux builder-chain HandlerFunc handlers" do
+      source = <<-GO
+        package main
+
+        func createUser(w http.ResponseWriter, r *http.Request) {
+          user := saveUser(r)
+          w.Write([]byte(user))
+        }
+
+        func register(r *mux.Router) {
+          r.Methods("POST").
+            Path("/users").
+            HandlerFunc(createUser)
+        }
+        GO
+
+      target_row = source.lines.index!(&.includes?("r.Methods(\"POST\")"))
+      callees = Noir::GoCalleeExtractor.callees_for_routes(
+        source, "main.go", Set{target_row},
+        Hash(String, Noir::GoCalleeExtractor::FunctionBody).new
+      )
+      names = callees[target_row].map(&.[0])
+
+      names.should contain("saveUser")
+      names.should contain("w.Write")
+    end
+
+    it "unwraps http.HandlerFunc wrappers in mux Handler chains" do
+      source = <<-GO
+        package main
+
+        func createUser(w http.ResponseWriter, r *http.Request) {
+          user := saveUser(r)
+          w.Write([]byte(user))
+        }
+
+        func register(r *mux.Router) {
+          r.Path("/users").
+            Methods("POST").
+            Handler(http.HandlerFunc(createUser))
+        }
+        GO
+
+      target_row = source.lines.index!(&.includes?("r.Path(\"/users\")"))
+      callees = Noir::GoCalleeExtractor.callees_for_routes(
+        source, "main.go", Set{target_row},
+        Hash(String, Noir::GoCalleeExtractor::FunctionBody).new
+      )
+      names = callees[target_row].map(&.[0])
+
+      names.should contain("saveUser")
+      names.should contain("w.Write")
+    end
   end
 end

spec/unit_test/miniparser/go_route_extractor_ts_spec.cr

@@ -194,4 +194,58 @@ describe Noir::TreeSitterGoRouteExtractor do
     routes = Noir::TreeSitterGoRouteExtractor.extract_routes(source)
     routes.map { |r| {r.verb, r.path} }.should eq([{"GET", "/legit"}])
   end
+
+  it "extracts gorilla mux Handle routes and named tail chains" do
+    source = <<-GO
+      package main
+      func main() {
+          r := mux.NewRouter()
+          r.Handle("/handler", http.HandlerFunc(handler)).Methods("POST").Name("handler.create")
+          r.HandleFunc("/multi", handler).Methods("GET", "POST").Name("multi")
+      }
+      GO
+
+    routes = Noir::TreeSitterGoRouteExtractor.extract_routes(source, handlefunc_methods: true)
+    routes.map { |r| {r.verb, r.path} }.sort!.should eq([
+      {"GET", "/multi"},
+      {"POST", "/handler"},
+      {"POST", "/multi"},
+    ].sort)
+  end
+
+  it "extracts gorilla mux route builder chains" do
+    source = <<-GO
+      package main
+      func main() {
+          r := mux.NewRouter()
+          r.Methods("GET").Path("/builder").HandlerFunc(handler)
+          r.Path("/alternate").Methods("PATCH").Handler(http.HandlerFunc(handler))
+          r.Methods("GET").Path("/filtered").Queries("type", "{type}", "page", "{page}").HandlerFunc(handler)
+      }
+      GO
+
+    routes = Noir::TreeSitterGoRouteExtractor.extract_routes(source, handlefunc_methods: true)
+    routes.map { |r| {r.verb, r.path, r.query_params} }.sort_by! { |r| r[1] }.should eq([
+      {"PATCH", "/alternate", [] of String},
+      {"GET", "/builder", [] of String},
+      {"GET", "/filtered", ["type", "page"]},
+    ])
+  end
+
+  it "preserves wildcard methods for unconstrained gorilla mux routes" do
+    source = <<-GO
+      package main
+      func main() {
+          r := mux.NewRouter()
+          r.HandleFunc("/all", handler)
+          r.Path("/all-builder").HandlerFunc(handler)
+      }
+      GO
+
+    routes = Noir::TreeSitterGoRouteExtractor.extract_routes(source, handlefunc_methods: true)
+    routes.map { |r| {r.verb, r.path} }.sort!.should eq([
+      {"ANY", "/all"},
+      {"ANY", "/all-builder"},
+    ].sort)
+  end
 end

src/miniparsers/go_callee_extractor.cr

@@ -150,7 +150,7 @@ module Noir::GoCalleeExtractor
         row = Noir::TreeSitter.node_start_row(node)
         next unless route_rows.includes?(row)
 
-        handler_arg = find_handler_arg(node, source)
+        handler_arg = find_handler_arg(node, source).try { |arg| unwrap_handler_arg(arg, source) }
         next unless handler_arg
 
         callees = [] of Tuple(String, String, Int32)
@@ -182,21 +182,62 @@ module Noir::GoCalleeExtractor
   # First non-string positional argument after a string-literal arg in a
   # verb-route call. Mirrors the convention used by
   # `TreeSitterGoRouteExtractor#decode_verb_call`.
+  #
+  # Mux builder chains are the exception: `.Path("/x").HandlerFunc(h)`
+  # carries the path and handler in different calls. When the routed call
+  # itself is `Handler` / `HandlerFunc`, the first non-string arg is the
+  # handler.
   private def find_handler_arg(call_node : LibTreeSitter::TSNode, source : String) : LibTreeSitter::TSNode?
     args = Noir::TreeSitter.field(call_node, "arguments")
     return unless args
+    handler_only = handler_only_call?(call_node, source)
     seen_path = false
     Noir::TreeSitter.each_named_child(args) do |arg|
       ty = Noir::TreeSitter.node_type(arg)
       if ty == "interpreted_string_literal" || ty == "raw_string_literal"
         seen_path = true
         next
       end
-      return arg if seen_path
+      return arg if seen_path || handler_only
     end
     nil
   end
 
+  private def handler_only_call?(call_node : LibTreeSitter::TSNode, source : String) : Bool
+    function = Noir::TreeSitter.field(call_node, "function")
+    return false unless function
+    return false unless Noir::TreeSitter.node_type(function) == "selector_expression"
+    field = Noir::TreeSitter.field(function, "field")
+    return false unless field
+
+    case Noir::TreeSitter.node_text(field, source)
+    when "Handler", "HandlerFunc"
+      true
+    else
+      false
+    end
+  end
+
+  private def unwrap_handler_arg(arg : LibTreeSitter::TSNode, source : String) : LibTreeSitter::TSNode
+    return arg unless Noir::TreeSitter.node_type(arg) == "call_expression"
+
+    function = Noir::TreeSitter.field(arg, "function")
+    return arg unless function
+    return arg unless Noir::TreeSitter.node_type(function) == "selector_expression"
+
+    field = Noir::TreeSitter.field(function, "field")
+    return arg unless field
+    return arg unless Noir::TreeSitter.node_text(field, source) == "HandlerFunc"
+
+    args = Noir::TreeSitter.field(arg, "arguments")
+    return arg unless args
+    Noir::TreeSitter.each_named_child(args) do |child|
+      return child unless Noir::TreeSitter.node_type(child) == "interpreted_string_literal" ||
+                          Noir::TreeSitter.node_type(child) == "raw_string_literal"
+    end
+    arg
+  end
+
   # Walk `body_node` for call expressions and append `(name, file_path,
   # file_line)` tuples. `line_offset` lets callers translate
   # tree-sitter rows (already absolute when the parse covers the whole