263 lines
7.3 KiB
Go
263 lines
7.3 KiB
Go
// Copyright (c) 2013 The Go Authors. All rights reserved.
|
|
// Copyright (c) 2018 Dominik Honnef. All rights reserved.
|
|
|
|
package stylecheck
|
|
|
|
import (
|
|
"go/ast"
|
|
"go/token"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"honnef.co/go/tools/lint"
|
|
. "honnef.co/go/tools/lint/lintdsl"
|
|
)
|
|
|
|
// knownNameExceptions is a set of names that are known to be exempt from naming checks.
|
|
// This is usually because they are constrained by having to match names in the
|
|
// standard library.
|
|
var knownNameExceptions = map[string]bool{
|
|
"LastInsertId": true, // must match database/sql
|
|
"kWh": true,
|
|
}
|
|
|
|
func (c *Checker) CheckNames(j *lint.Job) {
|
|
// A large part of this function is copied from
|
|
// github.com/golang/lint, Copyright (c) 2013 The Go Authors,
|
|
// licensed under the BSD 3-clause license.
|
|
|
|
allCaps := func(s string) bool {
|
|
for _, r := range s {
|
|
if !((r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_') {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
check := func(id *ast.Ident, thing string, initialisms map[string]bool) {
|
|
if id.Name == "_" {
|
|
return
|
|
}
|
|
if knownNameExceptions[id.Name] {
|
|
return
|
|
}
|
|
|
|
// Handle two common styles from other languages that don't belong in Go.
|
|
if len(id.Name) >= 5 && allCaps(id.Name) && strings.Contains(id.Name, "_") {
|
|
j.Errorf(id, "should not use ALL_CAPS in Go names; use CamelCase instead")
|
|
return
|
|
}
|
|
|
|
should := lintName(id.Name, initialisms)
|
|
if id.Name == should {
|
|
return
|
|
}
|
|
|
|
if len(id.Name) > 2 && strings.Contains(id.Name[1:len(id.Name)-1], "_") {
|
|
j.Errorf(id, "should not use underscores in Go names; %s %s should be %s", thing, id.Name, should)
|
|
return
|
|
}
|
|
j.Errorf(id, "%s %s should be %s", thing, id.Name, should)
|
|
}
|
|
checkList := func(fl *ast.FieldList, thing string, initialisms map[string]bool) {
|
|
if fl == nil {
|
|
return
|
|
}
|
|
for _, f := range fl.List {
|
|
for _, id := range f.Names {
|
|
check(id, thing, initialisms)
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, pkg := range j.Program.InitialPackages {
|
|
initialisms := make(map[string]bool, len(pkg.Config.Initialisms))
|
|
for _, word := range pkg.Config.Initialisms {
|
|
initialisms[word] = true
|
|
}
|
|
for _, f := range pkg.Syntax {
|
|
// Package names need slightly different handling than other names.
|
|
if !strings.HasSuffix(f.Name.Name, "_test") && strings.Contains(f.Name.Name, "_") {
|
|
j.Errorf(f, "should not use underscores in package names")
|
|
}
|
|
if strings.IndexFunc(f.Name.Name, unicode.IsUpper) != -1 {
|
|
j.Errorf(f, "should not use MixedCaps in package name; %s should be %s", f.Name.Name, strings.ToLower(f.Name.Name))
|
|
}
|
|
|
|
ast.Inspect(f, func(node ast.Node) bool {
|
|
switch v := node.(type) {
|
|
case *ast.AssignStmt:
|
|
if v.Tok != token.DEFINE {
|
|
return true
|
|
}
|
|
for _, exp := range v.Lhs {
|
|
if id, ok := exp.(*ast.Ident); ok {
|
|
check(id, "var", initialisms)
|
|
}
|
|
}
|
|
case *ast.FuncDecl:
|
|
// Functions with no body are defined elsewhere (in
|
|
// assembly, or via go:linkname). These are likely to
|
|
// be something very low level (such as the runtime),
|
|
// where our rules don't apply.
|
|
if v.Body == nil {
|
|
return true
|
|
}
|
|
|
|
if IsInTest(j, v) && (strings.HasPrefix(v.Name.Name, "Example") || strings.HasPrefix(v.Name.Name, "Test") || strings.HasPrefix(v.Name.Name, "Benchmark")) {
|
|
return true
|
|
}
|
|
|
|
thing := "func"
|
|
if v.Recv != nil {
|
|
thing = "method"
|
|
}
|
|
|
|
if !isTechnicallyExported(v) {
|
|
check(v.Name, thing, initialisms)
|
|
}
|
|
|
|
checkList(v.Type.Params, thing+" parameter", initialisms)
|
|
checkList(v.Type.Results, thing+" result", initialisms)
|
|
case *ast.GenDecl:
|
|
if v.Tok == token.IMPORT {
|
|
return true
|
|
}
|
|
var thing string
|
|
switch v.Tok {
|
|
case token.CONST:
|
|
thing = "const"
|
|
case token.TYPE:
|
|
thing = "type"
|
|
case token.VAR:
|
|
thing = "var"
|
|
}
|
|
for _, spec := range v.Specs {
|
|
switch s := spec.(type) {
|
|
case *ast.TypeSpec:
|
|
check(s.Name, thing, initialisms)
|
|
case *ast.ValueSpec:
|
|
for _, id := range s.Names {
|
|
check(id, thing, initialisms)
|
|
}
|
|
}
|
|
}
|
|
case *ast.InterfaceType:
|
|
// Do not check interface method names.
|
|
// They are often constrainted by the method names of concrete types.
|
|
for _, x := range v.Methods.List {
|
|
ft, ok := x.Type.(*ast.FuncType)
|
|
if !ok { // might be an embedded interface name
|
|
continue
|
|
}
|
|
checkList(ft.Params, "interface method parameter", initialisms)
|
|
checkList(ft.Results, "interface method result", initialisms)
|
|
}
|
|
case *ast.RangeStmt:
|
|
if v.Tok == token.ASSIGN {
|
|
return true
|
|
}
|
|
if id, ok := v.Key.(*ast.Ident); ok {
|
|
check(id, "range var", initialisms)
|
|
}
|
|
if id, ok := v.Value.(*ast.Ident); ok {
|
|
check(id, "range var", initialisms)
|
|
}
|
|
case *ast.StructType:
|
|
for _, f := range v.Fields.List {
|
|
for _, id := range f.Names {
|
|
check(id, "struct field", initialisms)
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// lintName returns a different name if it should be different.
|
|
func lintName(name string, initialisms map[string]bool) (should string) {
|
|
// A large part of this function is copied from
|
|
// github.com/golang/lint, Copyright (c) 2013 The Go Authors,
|
|
// licensed under the BSD 3-clause license.
|
|
|
|
// Fast path for simple cases: "_" and all lowercase.
|
|
if name == "_" {
|
|
return name
|
|
}
|
|
if strings.IndexFunc(name, func(r rune) bool { return !unicode.IsLower(r) }) == -1 {
|
|
return name
|
|
}
|
|
|
|
// Split camelCase at any lower->upper transition, and split on underscores.
|
|
// Check each word for common initialisms.
|
|
runes := []rune(name)
|
|
w, i := 0, 0 // index of start of word, scan
|
|
for i+1 <= len(runes) {
|
|
eow := false // whether we hit the end of a word
|
|
if i+1 == len(runes) {
|
|
eow = true
|
|
} else if runes[i+1] == '_' && i+1 != len(runes)-1 {
|
|
// underscore; shift the remainder forward over any run of underscores
|
|
eow = true
|
|
n := 1
|
|
for i+n+1 < len(runes) && runes[i+n+1] == '_' {
|
|
n++
|
|
}
|
|
|
|
// Leave at most one underscore if the underscore is between two digits
|
|
if i+n+1 < len(runes) && unicode.IsDigit(runes[i]) && unicode.IsDigit(runes[i+n+1]) {
|
|
n--
|
|
}
|
|
|
|
copy(runes[i+1:], runes[i+n+1:])
|
|
runes = runes[:len(runes)-n]
|
|
} else if unicode.IsLower(runes[i]) && !unicode.IsLower(runes[i+1]) {
|
|
// lower->non-lower
|
|
eow = true
|
|
}
|
|
i++
|
|
if !eow {
|
|
continue
|
|
}
|
|
|
|
// [w,i) is a word.
|
|
word := string(runes[w:i])
|
|
if u := strings.ToUpper(word); initialisms[u] {
|
|
// Keep consistent case, which is lowercase only at the start.
|
|
if w == 0 && unicode.IsLower(runes[w]) {
|
|
u = strings.ToLower(u)
|
|
}
|
|
// All the common initialisms are ASCII,
|
|
// so we can replace the bytes exactly.
|
|
// TODO(dh): this won't be true once we allow custom initialisms
|
|
copy(runes[w:], []rune(u))
|
|
} else if w > 0 && strings.ToLower(word) == word {
|
|
// already all lowercase, and not the first word, so uppercase the first character.
|
|
runes[w] = unicode.ToUpper(runes[w])
|
|
}
|
|
w = i
|
|
}
|
|
return string(runes)
|
|
}
|
|
|
|
func isTechnicallyExported(f *ast.FuncDecl) bool {
|
|
if f.Recv != nil || f.Doc == nil {
|
|
return false
|
|
}
|
|
|
|
const export = "//export "
|
|
const linkname = "//go:linkname "
|
|
for _, c := range f.Doc.List {
|
|
if strings.HasPrefix(c.Text, export) && len(c.Text) == len(export)+len(f.Name.Name) && c.Text[len(export):] == f.Name.Name {
|
|
return true
|
|
}
|
|
|
|
if strings.HasPrefix(c.Text, linkname) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|