Returns the list of verbs to emit for a given extracted route verb. ANY / ALL (case-insensitive — verbs are uppercased before they reach this helper) expand to every canonical HTTP method so downstream output formats list each method explicitly instead of carrying a non-HTTP "ANY" verb that tools like SARIF/Postman can't ingest. Anything else passes through as a single-element list.

Finds calls to any of the named builder functions and returns [{func_name, first_arg_identifier}]. The first argument names the group passed in (addUserRoutes(v1) -> {"addUserRoutes", "v1"}), which the caller resolves to a prefix via the package group map.

Detects top-level Gin router-builder helpers. The canonical gin project layout splits registration across func addXRoutes(rg *gin.RouterGroup) helpers called from a central getRoutes() with a versioned group (addUserRoutes(router.Group("/v1"))). The group prefix lives at the call site, not in the helper, so the helper's routes need that prefix grafted on (see #extract_routes_from_function). Returns {func_name => RouterBuilder}; only functions with exactly one *gin.RouterGroup parameter qualify (an ambiguous count can't be bound to a single prefix).

Extracts Beego controller-style routes:

web.Router("/health", ctrl, "get:Health") -> GET /health web.Router("/x", c, "get,post:Handle") -> GET /x, POST /x web.Router("/x", c, "get:Read;post:Write") -> GET /x, POST /x web.Router("/any", c, "*:Any") -> ANY /any (fan-out) web.Router("/", &MainController{}) -> verb routes for each HTTP method the controller implements

controller_methods (see #extract_controller_methods) supplies the method set for the mapping-less form; when the controller type can't be resolved (e.g. a cross-package &controllers.User{}), the route falls back to a single GET so the endpoint is still surfaced rather than dropped. The Route's handler carries the controller-method name so the analyzer can attribute it as a callee.

net/http-style registrations chi exposes alongside the verb shortcuts: r.MethodFunc("GET", "/x", h) (method as the first string arg, incl. custom verbs from chi.RegisterMethod) and r.HandleFunc("/x", h) / r.Handle("/x", h) (match ANY method). Gated behind ScopedConfig#net_http_methods? so the gf walker — which shares this recognizer — is untouched.

Collects Beego controller types and the HTTP-verb-named methods they implement, keyed by the (package-unqualified) type name. Used to resolve mapping-less web.Router("/path", &Ctrl{}) registrations into the concrete set of methods the controller serves. Built once per package directory by the Beego analyzer (controllers and their router registrations usually share a package).

Only HTTP-verb method names are recorded — a MainController that defines Get, Health, Update contributes {"MainController" => ["Get"]}, because Beego's default mapping only routes verb-named methods; Health/Update are reachable solely via an explicit "get:Health" mapping string.

Collects names that denote a root engine/router rather than a path-bearing group:

r := gin.New() / r := gin.Default() r := chi.NewRouter() / e := echo.New() func setup(r *gin.Engine) / func setup(e *echo.Echo)

The cross-file group pre-pass excludes these so a same-named local group in a sibling file (e.g. r := v1.Group("/sysjob")) can't leak a prefix onto the root and contaminate every route in the package. Each file still resolves its own r locally during route extraction; this only governs what crosses file boundaries.

Single-parse combination of #extract_engine_names + #extract_groups (with an empty external map). The Go engine's group pre-pass needs BOTH per file — the root-engine names to exclude from cross-file propagation and the file's own group declarations — so folding them into one tree-sitter parse halves the pre-pass parse count. Behaviour is identical to calling the two extractors separately; only the parse is shared.

GoFrame standardized routing: scan every type X struct { ... } for an embedded g.Meta field whose tag declares a route (path:"/x" method:"get"). Each such struct is one endpoint (or several, when method lists more than one verb). The struct's own named fields become request params. This is method-/group-agnostic on purpose: the tag fully specifies the route, the same way gf's OpenAPI generator treats it, so we don't need to resolve the group.Bind(...) site (whose prefix is often a runtime config value we can't see statically).

Goyave-style <router>.Static(&fs, "/prefix", false): the first /-prefixed string argument is the URL prefix; the disk path is derived by stripping its leading slash (matching the legacy extractor's behaviour, which used the same identifier for both).

go-zero registers routes as rest.Route struct literals rather than verb calls, in two shapes:

server.AddRoutes( # generated routes.go []rest.Route{ {Method: http.MethodPost, Path: "/user/login", Handler: h}, }, rest.WithPrefix("/usercenter/v1"), )

server.AddRoute(rest.Route{Method: http.MethodGet, Path: "/"}) apiGroup := server.Group("/api/v1") # hand-written grouping apiGroup.AddRoute(rest.Route{Path: "/products", ...})

The verb/path live in the struct (not a .Get(...) call), and the mount prefix comes from a trailing rest.WithPrefix(...) option and/or a server.Group("/p") receiver — so the generic verb extractor sees nothing. This decodes every route to its full mounted path so it dedupes against the same route declared (prefix-applied) in a .api file. handler carries the registered handler expression for callee wiring.

Extracts only <name> := <parent>.<group_method>("/prefix") declarations. Used by the Go engine to run a cross-file fixpoint so group names defined in one file but referenced in another are known by the time #extract_routes runs on the referencing file.

Mux-style <router>.PathPrefix("/x/").Handler(<... http.Dir("./x/") ...>). URL prefix comes from the PathPrefix arg; disk path from the http.Dir(...) call nested somewhere inside the Handler(...) argument expression.

Extracts routes registered directly against the Go standard library net/http package (and its ServeMux). This covers the very common bare-server pattern used in tutorials, internal tools and minimal services:

http.HandleFunc("/hello", handler) http.Handle("/api", h)

mux := http.NewServeMux() mux.HandleFunc("/users", uh) mux.Handle("/old", oh)

// Go 1.22+ method-in-pattern form (verb is known at registration) mux.HandleFunc("POST /items", ih)

The extractor ONLY returns registrations performed on:

• the net/http package identifier (or alias: import h "net/http"; h.HandleFunc)
• variables proven (via same-file assignment) to have originated from http.NewServeMux(), &http.ServeMux{}, or http.ServeMux{}

This guarantees zero collision with chi's HandleFunc/Handle (which are handled exclusively by the chi walker and would otherwise be mis-attributed if we reused the generic mux handlefunc chain decoder).

Routes are emitted with verb "ANY" (classic registrations match whatever the handler decides at runtime) or the concrete verb when the modern "METHOD /path" pattern form is used. Callers (the go_http analyzer) are responsible for fanning ANY via .fan_out_verbs.

Parses source and returns every verb route it can resolve. external_groups supplies group prefixes defined in other files of the same Go package, so cross-file patterns like routes.go calling v1.GET(...) under a v1 := r.Group("/v1") declared in main.go resolve correctly. group_method is the method name used for grouping — Gin/Echo/Fiber/ Hertz use .Group(...), Iris uses .Party(...). Mux uses the special two-call chain <parent>.PathPrefix("/prefix").Subrouter(); pass "Subrouter" and the collector will peek through the chain to pull the prefix from the .PathPrefix(...) call. handle_method is the "method-first" shape some routers use (httprouter's .Handle("METHOD", "/path", handler)); set to nil to disable. handlefunc_methods enables mux's <router>.HandleFunc("/path", h).Methods("METHOD") chain — the outer call is .Methods(...), so this piggybacks on the walk rather than decode_verb_call.

Extracts the verb routes registered inside one named function's body, seeding external_groups with the function's group parameter bound to a call-site prefix ({rg => "/v1"}). This grafts the call-site prefix onto routes a router-builder helper registers on its parameter group (users := rg.Group("/users"); users.GET("/") -> /v1/users/). Route line numbers stay relative to source so code paths remain accurate.

<router>.<method_name>("/prefix", "./dir", ...). The first two string args are taken as (url_prefix, disk_path). Covers the Gin/Echo/Fiber/Hertz/GoZero shape.

Collects <name> := "literal" / const <name> = "literal" string bindings from source, keyed by name. Real chi/mux apps routinely declare route paths as package constants (const tokenPath = "/api/v2/token") and register them with r.Get(tokenPath, h); the analyzer merges these per-package so the scoped walker can resolve a constant/variable path argument to its literal value. Conflicting redefinitions are dropped by collect_string_values.

Exposes the closure-scoped walker against an arbitrary node (typically a function body captured elsewhere). Uses chi defaults incl. the net/http registrations (MethodFunc/HandleFunc/Handle) so a Mount-expanded router function body is parsed like any chi file.