94 lines
3.0 KiB
Go
94 lines
3.0 KiB
Go
// Copyright 2023 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package astutil provides various AST utility functions for gopls.
|
|
package astutil
|
|
|
|
import (
|
|
"bytes"
|
|
"go/scanner"
|
|
"go/token"
|
|
)
|
|
|
|
// PurgeFuncBodies returns a copy of src in which the contents of each
|
|
// 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
|
|
// PurgeFuncBodies may result in a different tree due to its effects
|
|
// 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,
|
|
// 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))
|
|
var sc scanner.Scanner
|
|
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 a region we preserve
|
|
var ellipsis bool // saw "[...]" not yet consumed by a literal-body "{"
|
|
for {
|
|
pos, tok, _ := sc.Scan()
|
|
if tok == token.EOF {
|
|
break
|
|
}
|
|
switch tok {
|
|
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 // type body: preserve (don't consume ellipsis)
|
|
} else if ellipsis {
|
|
pos = -1 // [...]T literal body: preserve
|
|
ellipsis = false
|
|
}
|
|
braces = append(braces, pos)
|
|
|
|
case token.RBRACE:
|
|
if last := len(braces) - 1; last >= 0 {
|
|
top := braces[last]
|
|
braces = braces[:last]
|
|
if top < 0 {
|
|
// preserve
|
|
} else if len(braces) == 0 { // toplevel only
|
|
// Delete {...} body.
|
|
start := file.Offset(top)
|
|
end := file.Offset(pos)
|
|
out.Write(src[cursor : start+len("{")])
|
|
cursor = end
|
|
}
|
|
}
|
|
}
|
|
prev = tok
|
|
}
|
|
out.Write(src[cursor:])
|
|
return out.Bytes()
|
|
}
|