bazel: add go_stringer rule and Gazelle extension

### What does this PR do?
- add `bazel/tools/stringer_wrapper.sh` + `sh_binary`: wrapper that
  puts the rules_go `go` binary on PATH and cds to the package
  directory before invoking stringer, so the generated header matches
  `//go:generate` output exactly
- add `bazel/rules/go_stringer.bzl`: `go_stringer` Starlark macro
  wrapping `run_binary`; params: `name`, `src`, `type`, `gomod`,
  `output`, `trimprefix`, `linecomment`, `go_tags`, `**kwargs`
- add `internal/tools/gazelle-stringer/`: Gazelle language extension
  that reads `//go:generate stringer` directives and emits
  `go_stringer` rules; wired into a custom `gazelle_binary` at
  `//:gazelle`
- Bazelify `pkg/template` as proof of concept: BUILD.bazel files for
  the root package, `internal/fmtsort`, `text`, and `html`; the six
  `html` stringer targets, one `write_source_file` diff-test per
  target, and `go_library` targets; unexclude `pkg/template` from the
  root Gazelle exclusion list
- update checked-in `*_string.go` files in `pkg/template/html`; those
  files were copied from the Go stdlib in #36024 and had never been
  regenerated in this repo; the diffs reflect a newer
  `golang.org/x/tools` version bundled with rules_go vs what the Go
  team used at the time

### Motivation
Replaces manual `go generate` invocations with hermetic Bazel actions,
making the build self-contained and stringer outputs verifiable via
`bazel test`.

### Describe how you validated your changes
- `bazel build //pkg/template/html:...` builds all six stringer targets
  and the `go_library`
- `bazel test //pkg/template/...` passes six diff-tests (one per
  generated file)
- `bazel run //:gazelle -- -mode=diff` produces no diff

Author: rdesgroppes

BUILD.bazel

@@ -3,7 +3,7 @@
 load("@bazel_lib//lib:write_source_files.bzl", "write_source_file")
 load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
 load("@bazel_skylib//rules:run_binary.bzl", "run_binary")
-load("@gazelle//:def.bzl", "gazelle")
+load("@gazelle//:def.bzl", "gazelle", "gazelle_binary")
 
 package(default_visibility = ["//visibility:public"])
 
@@ -82,9 +82,19 @@ package(default_visibility = ["//visibility:public"])
 # gazelle:exclude tools
 # gazelle:exclude .gitlab
 # gazelle:prefix github.com/DataDog/datadog-agent
+gazelle_binary(
+    name = "gazelle_bin",
+    languages = [
+        "@gazelle//language/go",
+        "@gazelle//language/proto",
+        "//bazel/rules/go_stringer:gazelle",
+    ],
+)
+
 gazelle(
     name = "gazelle",
     args = ["-external=static"],  # don't use the network: https://github.com/bazel-contrib/bazel-gazelle/issues/1385
+    gazelle = ":gazelle_bin",
 )
 
 # bazel run //:go -- ...

bazel/rules/go_stringer/BUILD.bazel

@@ -0,0 +1,19 @@
+load("@rules_go//go:def.bzl", "go_library")
+load("@rules_shell//shell:sh_binary.bzl", "sh_binary")
+
+sh_binary(
+    name = "stringer_wrapper",
+    srcs = ["stringer_wrapper.sh"],
+    visibility = ["//visibility:public"],
+)
+
+go_library(
+    name = "gazelle",
+    srcs = ["gazelle.go"],
+    importpath = "github.com/DataDog/datadog-agent/bazel/rules/go_stringer",
+    visibility = ["//visibility:public"],
+    deps = [
+        "@gazelle//language",
+        "@gazelle//rule",
+    ],
+)

bazel/rules/go_stringer/defs.bzl

@@ -0,0 +1,47 @@
+load("@bazel_lib//lib:run_binary.bzl", "run_binary")
+load("@bazel_lib//lib:write_source_files.bzl", "write_source_file")
+
+_ENV = {
+    "GO_BIN": "$(execpath @rules_go//go)",
+    "STRINGER_BIN": "$(execpath @org_golang_x_tools//cmd/stringer)",
+}
+
+def _impl(name, mod, output, src, type, go_tags, linecomment, trimprefix, visibility):
+    out_new = output + ".new"
+    args = ["-type", type]
+    if output != type.split(",")[0].lower() + "_string.go":
+        args += ["-output", output]
+    if go_tags:
+        args += ["-tags", go_tags]
+    if linecomment:
+        args.append("-linecomment")
+    if trimprefix:
+        args += ["-trimprefix", trimprefix]
+    run_binary(
+        name = name + "_gen",
+        tool = "//bazel/rules/go_stringer:stringer_wrapper",
+        srcs = [src, "@rules_go//go", "@org_golang_x_tools//cmd/stringer", mod],
+        outs = [out_new],
+        args = args,
+        env = dict(
+            _ENV,
+            PKG_SRC = "$(execpath " + str(src) + ")",
+            STRINGER_OUT = "$(execpath " + out_new + ")",
+        ),
+        visibility = ["//visibility:private"],
+    )
+    native.exports_files([output])
+    write_source_file(name = name, in_file = ":" + name + "_gen", out_file = output, check_that_out_file_exists = False, visibility = visibility)
+
+go_stringer = macro(
+    implementation = _impl,
+    attrs = {
+        "mod": attr.label(mandatory = True, configurable = False),
+        "output": attr.string(mandatory = True, configurable = False),
+        "src": attr.label(mandatory = True, configurable = False),
+        "type": attr.string(mandatory = True, configurable = False),
+        "go_tags": attr.string(configurable = False),
+        "linecomment": attr.bool(default = False, configurable = False),
+        "trimprefix": attr.string(configurable = False),
+    },
+)

bazel/rules/go_stringer/gazelle.go

@@ -0,0 +1,172 @@
+// Package stringer is a Gazelle extension that generates go_stringer rules
+// from //go:generate stringer directives in Go source files.
+package stringer
+
+import (
+	"bufio"
+	"flag"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/bazelbuild/bazel-gazelle/language"
+	"github.com/bazelbuild/bazel-gazelle/rule"
+)
+
+// NewLanguage is called by Gazelle to instantiate this extension.
+func NewLanguage() language.Language {
+	return &lang{}
+}
+
+type lang struct {
+	language.BaseLang
+}
+
+func (*lang) Name() string { return "stringer" }
+
+func (*lang) Kinds() map[string]rule.KindInfo {
+	return map[string]rule.KindInfo{
+		"go_stringer": {
+			MatchAttrs:     []string{"output"},
+			NonEmptyAttrs:  map[string]bool{"src": true, "type": true, "mod": true, "output": true},
+			MergeableAttrs: map[string]bool{},
+		},
+	}
+}
+
+func (*lang) Loads() []rule.LoadInfo {
+	return []rule.LoadInfo{{
+		Name:    "//bazel/rules/go_stringer:defs.bzl",
+		Symbols: []string{"go_stringer"},
+	}}
+}
+
+func (*lang) GenerateRules(args language.GenerateArgs) language.GenerateResult {
+	mod := findGomod(args.Config.RepoRoot, args.Dir)
+	var rules []*rule.Rule
+
+	for _, f := range args.RegularFiles {
+		if !strings.HasSuffix(f, ".go") {
+			continue
+		}
+		directives, err := parseFile(filepath.Join(args.Dir, f))
+		if err != nil {
+			continue
+		}
+		for _, d := range directives {
+			out := d.output
+			if out == "" {
+				out = strings.ToLower(strings.SplitN(d.typ, ",", 2)[0]) + "_string.go"
+			}
+			r := rule.NewRule("go_stringer", strings.TrimSuffix(out, ".go"))
+			r.SetAttr("src", f)
+			r.SetAttr("type", d.typ)
+			r.SetAttr("mod", mod)
+			r.SetAttr("output", out)
+			if d.trimprefix != "" {
+				r.SetAttr("trimprefix", d.trimprefix)
+			}
+			if d.linecomment {
+				r.SetAttr("linecomment", true)
+			}
+			if d.tags != "" {
+				r.SetAttr("go_tags", d.tags)
+			}
+			rules = append(rules, r)
+		}
+	}
+	if len(rules) == 0 {
+		return language.GenerateResult{}
+	}
+	return language.GenerateResult{
+		Gen:     rules,
+		Imports: make([]interface{}, len(rules)),
+	}
+}
+
+type directive struct {
+	typ        string
+	output     string
+	trimprefix string
+	linecomment bool
+	tags       string
+}
+
+func parseFile(path string) ([]directive, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var result []directive
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "//go:generate ") {
+			continue
+		}
+		if d, ok := parseDirective(strings.TrimPrefix(line, "//go:generate ")); ok {
+			result = append(result, d)
+		}
+	}
+	return result, scanner.Err()
+}
+
+func parseDirective(s string) (directive, bool) {
+	fields := strings.Fields(s)
+	if len(fields) == 0 {
+		return directive{}, false
+	}
+	var args []string
+	switch {
+	case isStringerCmd(fields[0]):
+		args = fields[1:]
+	case fields[0] == "go" && len(fields) >= 3 && fields[1] == "run" && isStringerCmd(fields[2]):
+		args = fields[3:]
+	default:
+		return directive{}, false
+	}
+
+	fs := flag.NewFlagSet("stringer", flag.ContinueOnError)
+	fs.SetOutput(io.Discard)
+	typ := fs.String("type", "", "")
+	output := fs.String("output", "", "")
+	trimprefix := fs.String("trimprefix", "", "")
+	linecomment := fs.Bool("linecomment", false, "")
+	tags := fs.String("tags", "", "")
+	if err := fs.Parse(args); err != nil || *typ == "" {
+		return directive{}, false
+	}
+	return directive{
+		typ:         *typ,
+		output:      *output,
+		trimprefix:  *trimprefix,
+		linecomment: *linecomment,
+		tags:        *tags,
+	}, true
+}
+
+func isStringerCmd(s string) bool {
+	return s == "stringer" ||
+		strings.HasSuffix(s, "/stringer") ||
+		strings.HasSuffix(s, "/cmd/stringer")
+}
+
+func findGomod(repoRoot, dir string) string {
+	for d := dir; ; {
+		if _, err := os.Stat(filepath.Join(d, "go.mod")); err == nil {
+			rel, err := filepath.Rel(repoRoot, d)
+			if err != nil || rel == "." {
+				return "//:go.mod"
+			}
+			return "//" + filepath.ToSlash(rel) + ":go.mod"
+		}
+		parent := filepath.Dir(d)
+		if parent == d {
+			return "//:go.mod"
+		}
+		d = parent
+	}
+}

bazel/rules/go_stringer/stringer_wrapper.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+EXECROOT="$PWD"
+export PATH="$EXECROOT/$(dirname "$GO_BIN"):$PATH"
+export GOWORK=off
+export HOME=/tmp
+
+cd "$EXECROOT/$(dirname "$PKG_SRC")"
+"$EXECROOT/$STRINGER_BIN" "$@"
+mv "$(basename "$STRINGER_OUT" .new)" "$EXECROOT/$STRINGER_OUT"

pkg/template/BUILD.bazel

@@ -1,5 +1,10 @@
 load("@rules_go//go:def.bzl", "go_library")
 
+exports_files(
+    ["go.mod"],
+    visibility = ["//pkg/template:__subpackages__"],
+)
+
 go_library(
     name = "template",
     srcs = ["docs.go"],

pkg/template/html/BUILD.bazel

@@ -1,4 +1,53 @@
 load("@rules_go//go:def.bzl", "go_library")
+load("//bazel/rules/go_stringer:defs.bzl", "go_stringer")
+
+go_stringer(
+    name = "state_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "state_string.go",
+    type = "state",
+)
+
+go_stringer(
+    name = "delim_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "delim_string.go",
+    type = "delim",
+)
+
+go_stringer(
+    name = "urlpart_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "urlpart_string.go",
+    type = "urlPart",
+)
+
+go_stringer(
+    name = "jsctx_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "jsctx_string.go",
+    type = "jsCtx",
+)
+
+go_stringer(
+    name = "element_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "element_string.go",
+    type = "element",
+)
+
+go_stringer(
+    name = "attr_string",
+    src = "context.go",
+    mod = "//pkg/template:go.mod",
+    output = "attr_string.go",
+    type = "attr",
+)
 
 go_library(
     name = "html",