chore: allow handlers to have params with different names

group.go

@@ -66,15 +66,16 @@ func (g *Group) Handle(meth string, path string, handler HandlerFunc) {
 			panic(fmt.Errorf("routes %q and %q can't both handle %s", node.route, path, meth))
 		}
 	}
-	node.setHandler(meth, g.wrap(handler))
-
-	if !paramsEqual(node.params, params) {
-		panic(fmt.Errorf("routes %q and %q have different param names for the same route",
-			node.route, path))
-	}
+	node.setHandler(meth, &routeHandler{
+		fn:     g.wrap(handler),
+		params: params,
+	})
 
 	if node.handlerMap.notAllowed == nil {
-		node.handlerMap.notAllowed = g.wrap(g.router.methodNotAllowedHandler)
+		node.handlerMap.notAllowed = &routeHandler{
+			fn:     g.wrap(g.router.methodNotAllowedHandler),
+			params: params,
+		}
 	}
 }
 

node.go

@@ -11,7 +11,6 @@ type node struct {
 	route string
 	part  string
 
-	params     map[string]int // param name => param position
 	handlerMap *handlerMap
 
 	parent *node
@@ -36,7 +35,6 @@ func (n *node) addRoute(route string) (*node, map[string]int) {
 
 	if currNode.route == "" {
 		currNode.route = route
-		currNode.params = params
 	}
 	n.indexNodes()
 
@@ -108,7 +106,7 @@ func (n *node) addPart(part string) *node {
 	return node
 }
 
-func (n *node) findRoute(meth, path string) (*node, HandlerFunc, int) {
+func (n *node) findRoute(meth, path string) (*node, *routeHandler, int) {
 	if path == "" {
 		return nil, nil, 0
 	}
@@ -124,7 +122,7 @@ func (n *node) findRoute(meth, path string) (*node, HandlerFunc, int) {
 	return n._findRoute(meth, path)
 }
 
-func (n *node) _findRoute(meth, path string) (*node, HandlerFunc, int) {
+func (n *node) _findRoute(meth, path string) (*node, *routeHandler, int) {
 	var found *node
 
 	if firstChar := path[0]; firstChar >= n.index.minChar && firstChar <= n.index.maxChar {
@@ -219,7 +217,7 @@ func (n *node) _indexNodes() {
 	}
 }
 
-func (n *node) setHandler(verb string, handler HandlerFunc) {
+func (n *node) setHandler(verb string, handler *routeHandler) {
 	if n.handlerMap == nil {
 		n.handlerMap = newHandlerMap()
 	}
@@ -336,21 +334,26 @@ func paramMap(route string, params []string) map[string]int {
 //------------------------------------------------------------------------------
 
 type handlerMap struct {
-	get        HandlerFunc
-	post       HandlerFunc
-	put        HandlerFunc
-	delete     HandlerFunc
-	head       HandlerFunc
-	options    HandlerFunc
-	patch      HandlerFunc
-	notAllowed HandlerFunc
+	get        *routeHandler
+	post       *routeHandler
+	put        *routeHandler
+	delete     *routeHandler
+	head       *routeHandler
+	options    *routeHandler
+	patch      *routeHandler
+	notAllowed *routeHandler
+}
+
+type routeHandler struct {
+	fn     HandlerFunc
+	params map[string]int // param name => param position
 }
 
 func newHandlerMap() *handlerMap {
 	return new(handlerMap)
 }
 
-func (h *handlerMap) Get(meth string) HandlerFunc {
+func (h *handlerMap) Get(meth string) *routeHandler {
 	switch meth {
 	case http.MethodGet:
 		return h.get
@@ -371,7 +374,7 @@ func (h *handlerMap) Get(meth string) HandlerFunc {
 	}
 }
 
-func (h *handlerMap) Set(meth string, handler HandlerFunc) {
+func (h *handlerMap) Set(meth string, handler *routeHandler) {
 	switch meth {
 	case http.MethodGet:
 		h.get = handler
@@ -391,15 +394,3 @@ func (h *handlerMap) Set(meth string, handler HandlerFunc) {
 		panic(fmt.Errorf("unknown HTTP method: %s", meth))
 	}
 }
-
-func paramsEqual(m1, m2 map[string]int) bool {
-	if len(m1) != len(m2) {
-		return false
-	}
-	for k, v1 := range m1 {
-		if v2, ok := m2[k]; !ok || v1 != v2 {
-			return false
-		}
-	}
-	return true
-}

request.go

@@ -104,6 +104,7 @@ func (req Request) Route() string {
 type Params struct {
 	path        string
 	node        *node
+	handler     *routeHandler
 	wildcardLen uint16
 }
 
@@ -122,7 +123,7 @@ func (ps Params) Get(name string) (string, bool) {
 	if ps.node == nil {
 		return "", false
 	}
-	if i, ok := ps.node.params[name]; ok {
+	if i, ok := ps.handler.params[name]; ok {
 		return ps.findParam(i)
 	}
 	return "", false
@@ -132,7 +133,7 @@ func (ps *Params) findParam(paramIndex int) (string, bool) {
 	path := ps.path
 	pathLen := len(path)
 	currNode := ps.node
-	currParamIndex := len(ps.node.params) - 1
+	currParamIndex := len(ps.handler.params) - 1
 
 	// Wildcard can be only in the final node.
 	if ps.node.isWC {
@@ -196,11 +197,11 @@ func (ps Params) Int64(name string) (int64, error) {
 }
 
 func (ps Params) Map() map[string]string {
-	if ps.node == nil || len(ps.node.params) == 0 {
+	if ps.handler == nil || len(ps.handler.params) == 0 {
 		return nil
 	}
-	m := make(map[string]string, len(ps.node.params))
-	for param, index := range ps.node.params {
+	m := make(map[string]string, len(ps.handler.params))
+	for param, index := range ps.handler.params {
 		if value, ok := ps.findParam(index); ok {
 			m[param] = value
 		}
@@ -214,11 +215,11 @@ type Param struct {
 }
 
 func (ps Params) Slice() []Param {
-	if ps.node == nil || len(ps.node.params) == 0 {
+	if ps.handler == nil || len(ps.handler.params) == 0 {
 		return nil
 	}
-	slice := make([]Param, len(ps.node.params))
-	for param, index := range ps.node.params {
+	slice := make([]Param, len(ps.handler.params))
+	for param, index := range ps.handler.params {
 		if value, ok := ps.findParam(index); ok {
 			slice[index] = Param{Key: param, Value: value}
 		}

router.go

@@ -73,8 +73,9 @@ func (r *Router) lookup(w http.ResponseWriter, req *http.Request) (HandlerFunc,
 		handler = node.handlerMap.notAllowed
 	}
 
-	return handler, Params{
+	return handler.fn, Params{
 		node:        node,
+		handler:     handler,
 		path:        path,
 		wildcardLen: uint16(wildcardLen),
 	}

router_test.go

@@ -1005,20 +1005,35 @@ func TestMultipleMiddlewaresAndMethodNotAllowed(t *testing.T) {
 func TestSameRouteWithDifferentParams(t *testing.T) {
 	router := New()
 
-	router.GET("/:foo", dummyHandler)
-	require.PanicsWithError(
-		t,
-		`routes "/:foo" and "/:bar" have different param names for the same route`,
-		func() {
-			router.HEAD("/:bar", dummyHandler)
-		},
-	)
+	router.GET("/:foo", func(w http.ResponseWriter, req Request) error {
+		require.Equal(t, map[string]string{"foo": "hello"}, req.Params().Map())
+		return nil
+	})
+	router.HEAD("/:bar", func(w http.ResponseWriter, req Request) error {
+		require.Equal(t, map[string]string{"bar": "hello"}, req.Params().Map())
+		return nil
+	})
+
+	{
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("GET", "/hello", nil)
+		router.ServeHTTP(w, req)
+		require.Equal(t, http.StatusOK, w.Code)
+	}
+
+	{
+		w := httptest.NewRecorder()
+		req, _ := http.NewRequest("HEAD", "/hello", nil)
+		router.ServeHTTP(w, req)
+		require.Equal(t, http.StatusOK, w.Code)
+	}
 }
 
 func TestConflictingPlainAndWilcardRoutes(t *testing.T) {
 	router := New()
 
 	router.GET("/", dummyHandler)
+	router.POST("/*path", dummyHandler)
 	require.PanicsWithError(
 		t,
 		`routes "/" and "/*path" can't both handle GET`,