diff --git a/internal/astutil/purge.go b/internal/astutil/purge.go
index 81ac46a..d0a3941 100644
--- a/internal/astutil/purge.go
+++ b/internal/astutil/purge.go
@@ -12,9 +12,14 @@
 )
 
 // PurgeFuncBodies returns a copy of src in which the contents of each
-// outermost {...} region except struct and interface types have been
-// deleted. This reduces the amount of work required to parse the
-// top-level declarations.
+// outermost {...} region have been deleted, except for struct and
+// interface type bodies and the bodies of length-elided array
+// literals ([...]T), whose element count is part of the type. It
+// includes function bodies, function-literal bodies, and the bodies
+// of slice, map, and explicitly-sized array composite literals (whose
+// contents don't affect the type of the enclosing declaration). This
+// reduces the amount of work required to parse the top-level
+// declarations.
 //
 // PurgeFuncBodies does not preserve newlines or position information.
 // Also, if the input is invalid, parsing the output of
@@ -22,11 +27,12 @@
 // on parser error recovery.
 func PurgeFuncBodies(src []byte) []byte {
 	// Destroy the content of any {...}-bracketed regions that are
-	// not immediately preceded by a "struct" or "interface"
-	// token.  That includes function bodies, composite literals,
-	// switch/select bodies, and all blocks of statements.
-	// This will lead to non-void functions that don't have return
-	// statements, which of course is a type error, but that's ok.
+	// not immediately preceded by a "struct" or "interface" token,
+	// and that are not the body of a length-elided array literal.
+	// That includes function bodies, switch/select bodies, and most
+	// composite literals; this will lead to non-void functions that
+	// don't have return statements, which of course is a type error,
+	// but that's ok.
 
 	var out bytes.Buffer
 	file := token.NewFileSet().AddFile("", -1, len(src))
@@ -34,7 +40,8 @@
 	sc.Init(file, src, nil, 0)
 	var prev token.Token
 	var cursor int         // last consumed src offset
-	var braces []token.Pos // stack of unclosed braces or -1 for struct/interface type
+	var braces []token.Pos // stack of unclosed braces, or -1 for a region we preserve
+	var ellipsis bool      // saw "[...]" not yet consumed by a literal-body "{"
 	for {
 		pos, tok, _ := sc.Scan()
 		if tok == token.EOF {
@@ -44,9 +51,23 @@
 		case token.COMMENT:
 			// TODO(adonovan): opt: skip, to save an estimated 20% of time.
 
+		case token.SEMICOLON:
+			ellipsis = false
+
+		case token.RBRACK:
+			// "...]" occurs only in the array-type prefix of a
+			// composite literal; variadic "..." is followed by
+			// a type or ")", never "]".
+			if prev == token.ELLIPSIS {
+				ellipsis = true
+			}
+
 		case token.LBRACE:
 			if prev == token.STRUCT || prev == token.INTERFACE {
-				pos = -1
+				pos = -1 // type body: preserve (don't consume ellipsis)
+			} else if ellipsis {
+				pos = -1 // [...]T literal body: preserve
+				ellipsis = false
 			}
 			braces = append(braces, pos)
 
@@ -55,7 +76,7 @@
 				top := braces[last]
 				braces = braces[:last]
 				if top < 0 {
-					// struct/interface type: leave alone
+					// preserve
 				} else if len(braces) == 0 { // toplevel only
 					// Delete {...} body.
 					start := file.Offset(top)
diff --git a/internal/astutil/purge_test.go b/internal/astutil/purge_test.go
index 3de6bdc..6db426d 100644
--- a/internal/astutil/purge_test.go
+++ b/internal/astutil/purge_test.go
@@ -17,6 +17,133 @@
 	"golang.org/x/tools/internal/testenv"
 )
 
+func TestPurgeFuncBodiesCases(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "func decl",
+			in:   "package p\nfunc F(x int) string { return fmt.Sprint(x) }\n",
+			want: "package p\nfunc F(x int) string {}\n",
+		},
+		{
+			name: "method decl",
+			in:   "package p\nfunc (r R) M() int { return r.x }\n",
+			want: "package p\nfunc (r R) M() int {}\n",
+		},
+		{
+			name: "generic func decl",
+			in:   "package p\nfunc F[T any](x T) T { return x }\n",
+			want: "package p\nfunc F[T any](x T) T {}\n",
+		},
+		{
+			name: "no body (assembly)",
+			in:   "package p\nfunc F()\nfunc G() { x() }\n",
+			want: "package p\nfunc F()\nfunc G() {}\n",
+		},
+		// Result types containing braces: type literal preserved,
+		// only the body is purged.
+		{
+			name: "struct result type",
+			in:   "package p\nfunc F() struct{A int} { panic(0) }\n",
+			want: "package p\nfunc F() struct{A int} {}\n",
+		},
+		{
+			name: "interface result type",
+			in:   "package p\nfunc F() interface{M()} { return nil }\n",
+			want: "package p\nfunc F() interface{M()} {}\n",
+		},
+		{
+			name: "ptr struct result type",
+			in:   "package p\nfunc F() *struct{A int} { return nil }\n",
+			want: "package p\nfunc F() *struct{A int} {}\n",
+		},
+		{
+			name: "func type result",
+			in:   "package p\nfunc F() func() int { return nil }\n",
+			want: "package p\nfunc F() func() int {}\n",
+		},
+		// Length-elided array literals ([...]T) are preserved: the
+		// element count is part of the type. (Nested elements are
+		// preserved verbatim along with the outer body.)
+		{
+			name: "auto-sized array",
+			in:   "package p\nvar X = [...]int{1, 2, 3}\n",
+			want: "package p\nvar X = [...]int{1, 2, 3}\n",
+		},
+		{
+			name: "auto-sized array with key",
+			in:   "package p\nvar X = [...]int{5: 0}\n",
+			want: "package p\nvar X = [...]int{5: 0}\n",
+		},
+		{
+			name: "auto-sized array of struct",
+			in:   "package p\nvar X = [...]struct{A int}{{1}, {2}}\n",
+			want: "package p\nvar X = [...]struct{A int}{{1}, {2}}\n",
+		},
+		{
+			name: "const from auto-sized array",
+			in:   "package p\nconst N = len([...]int{1, 2, 3})\n",
+			want: "package p\nconst N = len([...]int{1, 2, 3})\n",
+		},
+		{
+			name: "auto-sized array then unrelated literal",
+			in:   "package p\nvar X = [...]int{1}\nvar Y = T{2}\n",
+			want: "package p\nvar X = [...]int{1}\nvar Y = T{}\n",
+		},
+		// Other composite literals are purged: their contents don't
+		// affect the type of the enclosing declaration.
+		{
+			name: "slice composite literal",
+			in:   "package p\nvar X = []int{1, 2, 3}\n",
+			want: "package p\nvar X = []int{}\n",
+		},
+		{
+			name: "fixed-size array composite literal",
+			in:   "package p\nvar X = [3]int{1, 2, 3}\n",
+			want: "package p\nvar X = [3]int{}\n",
+		},
+		{
+			name: "map composite literal",
+			in:   "package p\nvar X = map[string]func(){\"a\": f}\n",
+			want: "package p\nvar X = map[string]func(){}\n",
+		},
+		{
+			name: "struct composite literal",
+			in:   "package p\nvar X = struct{Y int}{Y: 1}\n",
+			want: "package p\nvar X = struct{Y int}{}\n",
+		},
+		// Func-literal bodies are purged.
+		{
+			name: "func literal in initializer",
+			in:   "package p\nvar F = func() int { return 1 }\n",
+			want: "package p\nvar F = func() int {}\n",
+		},
+		// Type-declaration bodies are preserved.
+		{
+			name: "type decl struct body",
+			in:   "package p\ntype T struct{ X int }\n",
+			want: "package p\ntype T struct{ X int }\n",
+		},
+		// "..." in non-array contexts does not trigger preservation.
+		{
+			name: "variadic param",
+			in:   "package p\nfunc F(x ...int) { y(x) }\n",
+			want: "package p\nfunc F(x ...int) {}\n",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := string(astutil.PurgeFuncBodies([]byte(tt.in)))
+			if got != tt.want {
+				t.Errorf("PurgeFuncBodies:\n in: %q\ngot: %q\nwant: %q", tt.in, got, tt.want)
+			}
+		})
+	}
+}
+
 // TestPurgeFuncBodies tests PurgeFuncBodies by comparing it against a
 // (less efficient) reference implementation that purges after parsing.
 func TestPurgeFuncBodies(t *testing.T) {
@@ -60,6 +187,14 @@
 				case *ast.FuncLit:
 					n.Body.List = nil
 				case *ast.CompositeLit:
+					if at, _ := n.Type.(*ast.ArrayType); at != nil {
+						if _, ok := at.Len.(*ast.Ellipsis); ok {
+							// [...]T literal: preserve verbatim
+							// (don't recur, since nested elements
+							// are preserved too).
+							return false
+						}
+					}
 					n.Elts = nil
 				}
 				return true