Add 'go_naming_convention' support.

Add directive 'go_naming_convention' to control the name of
generated Go rules.

go_default_library: Legacy behaviour.
import: Name targets after their import path.
import_alias: Same as import, but generate alias targets to
  maintain backwards compatibility with go_default_library.

We also add a `build_naming_convention` attribute to
`go_repository` rules, allowing per-external control over
the naming convention.

gazelle fix is augmented to migrate between the different
styles, both forwards and backwards.

FIXES=bazel-contrib#5

Author: tomlu

README.rst

@@ -336,6 +336,11 @@ The following flags are accepted:
 | See `Predefined plugins`_ for available options; commonly used options include                        |
 | ``@io_bazel_rules_go//proto:gofast_grpc`` and ``@io_bazel_rules_go//proto:gogofaster_grpc``.          |
 +--------------------------------------------------------------+----------------------------------------+
+| :flag:`-go_naming_convention`                                |                                        |
++--------------------------------------------------------------+----------------------------------------+
+| Controls the names of generated Go targets. Equivalent to the                                         |
+| # gazelle:go_naming_convention directive.                                                             |
++--------------------------------------------------------------+----------------------------------------+
 | :flag:`-go_prefix example.com/repo`                          |                                        |
 +--------------------------------------------------------------+----------------------------------------+
 | A prefix of import paths for libraries in the repository that corresponds to                          |
@@ -575,6 +580,22 @@ The following directives are recognized:
 | ``@io_bazel_rules_go//proto:gofast_grpc`` and                                              |
 | ``@io_bazel_rules_go//proto:gogofaster_grpc``.                                             |
 +---------------------------------------------------+----------------------------------------+
+| :direc:`# gazelle:go_naming_convention`           | n/a                                    |
++---------------------------------------------------+----------------------------------------+
+| Controls the names of generated Go targets. By default, library targets are named          |
+| `go_default_library` and test targets `go_default_test`.                                   |
+|  Valid values are:                                                                         |
+| * ``go_default_library``: Library targets are named ``go_default_library``, test targets   |
+|   are named ``go_default_test``.                                                           |
+| * ``import``: Library and test targets are named after the last segment of their import    |
+|   path.                                                                                    |
+|   For example, ``example.repo/foo`` is named ``foo``, and the test target is ``foo_test``. |
+|   Major version suffixes like ``/v2`` are dropped.                                         |
+|   For a main package with a binary ``foobin``, the names are instead ``foobin_lib`` and    |
+|   ``foobin_test``.                                                                         |
+| * ``import_alias``: Same as ``import``, but an ``alias`` target is generated named         |
+|   ``go_default_library`` to ensure backwards compatibility.                                |
++---------------------------------------------------+----------------------------------------+
 | :direc:`# gazelle:go_proto_compilers`             | ``@io_bazel_rules_go//proto:go_proto`` |
 +---------------------------------------------------+----------------------------------------+
 | The protocol buffers compiler(s) to use for building go bindings.                          |

cmd/gazelle/fix-update.go

@@ -147,12 +147,15 @@ func (ucr *updateConfigurer) CheckFlags(fs *flag.FlagSet, c *config.Config) erro
 			GoPrefix: imp,
 		})
 	}
+	goRepos := make(map[string]repo.Repo)
 	for _, r := range c.Repos {
 		if r.Kind() == "go_repository" {
-			uc.repos = append(uc.repos, repo.Repo{
-				Name:     r.Name(),
-				GoPrefix: r.AttrString("importpath"),
-			})
+			gr := repo.Repo{
+				Name:                  r.Name(),
+				GoPrefix:              r.AttrString("importpath"),
+			}
+			uc.repos = append(uc.repos, gr)
+			goRepos[r.Name()] = gr
 		}
 	}
 

internal/go_repository.bzl

@@ -191,6 +191,14 @@ go_repository = repository_rule(
     attrs = {
         # Fundamental attributes of a go repository
         "importpath": attr.string(mandatory = True),
+        "build_naming_convention": attr.string(
+            values = [
+                "",
+                "go_default_library",
+                "import",
+                "import_alias",
+            ],
+        ),
 
         # Attributes for a repository that should be checked out from VCS
         "commit": attr.string(),

language/go/config.go

@@ -77,6 +77,9 @@ type goConfig struct {
 	// goGenerateProto indicates whether to generate go_proto_library
 	goGenerateProto bool
 
+	// goNamingConvention controls the name of generated targets
+	goNamingConvention namingConvention
+
 	// goProtoCompilers is the protocol buffers compiler(s) to use for go code.
 	goProtoCompilers []string
 
@@ -104,6 +107,10 @@ type goConfig struct {
 	// resolved differently (also depending on goRepositoryMode).
 	moduleMode bool
 
+	// map between external repo names and their `build_naming_convention`
+	// attribute.
+	repoNamingConvention map[string]namingConvention
+
 	// submodules is a list of modules which have the current module's path
 	// as a prefix of their own path. This affects visibility attributes
 	// in internal packages.
@@ -171,6 +178,15 @@ func (gc *goConfig) setBuildTags(tags string) error {
 	return nil
 }
 
+func (gc *goConfig) setNamingConvention(s string) error {
+	if nc, ok := namingConventionFromString(s); ok {
+		gc.goNamingConvention = nc
+		return nil
+	} else {
+		return fmt.Errorf("unknown go_naming_convention %q", s)
+	}
+}
+
 func getProtoMode(c *config.Config) proto.Mode {
 	if gc := getGoConfig(c); !gc.goGenerateProto {
 		return proto.DisableMode
@@ -236,6 +252,59 @@ func (f tagsFlag) String() string {
 	return ""
 }
 
+type goNamingConventionFlag func(string) error
+
+func (f goNamingConventionFlag) Set(value string) error {
+	return f(value)
+}
+
+func (f goNamingConventionFlag) String() string {
+	return ""
+}
+
+// namingConvention determines how go targets are named.
+type namingConvention int
+
+const (
+	// 'go_default_library', 'go_default_test', and TODO(tomlu)
+	goDefaultLibraryNC = iota
+
+	// For an import path that ends with foo, the go_library rules target is
+	// named 'foo', the go_test is named 'foo_test'.
+	// For a main package, the go_binary takes the 'foo' name, the library
+	// is named 'foo_lib', and the go_test is named 'foo_test'.
+	importNC
+
+	// Same as importNC, but generate alias rules for libraries that have
+	// the legacy 'go_default_library' name.
+	importAliasNC
+)
+
+func (nc namingConvention) String() string {
+	switch nc {
+	case goDefaultLibraryNC:
+		return "go_default_library"
+	case importNC:
+		return "import"
+	case importAliasNC:
+		return "import_alias"
+	}
+	return ""
+}
+
+func namingConventionFromString(s string) (namingConvention, bool) {
+	switch s {
+	case "go_default_library":
+		return goDefaultLibraryNC, true
+	case "import":
+		return importNC, true
+	case "import_alias":
+		return importAliasNC, true
+	default:
+		return goDefaultLibraryNC, false
+	}
+}
+
 type moduleRepo struct {
 	repoName, modulePath string
 }
@@ -249,6 +318,7 @@ func (*goLang) KnownDirectives() []string {
 		"build_tags",
 		"go_generate_proto",
 		"go_grpc_compilers",
+		"go_naming_convention",
 		"go_proto_compilers",
 		"go_visibility",
 		"importmap_prefix",
@@ -290,6 +360,10 @@ func (*goLang) RegisterFlags(fs *flag.FlagSet, cmd string, c *config.Config) {
 			"go_repository_module_mode",
 			false,
 			"set when gazelle is invoked by go_repository in module mode")
+		fs.Var(
+			goNamingConventionFlag(gc.setNamingConvention),
+			"go_naming_convention",
+			"controls generated library names. One of (go_default_library, import, import_alias)")
 
 	case "update-repos":
 		fs.Var(&gzflag.AllowedStringFlag{Value: &gc.buildExternalAttr, Allowed: validBuildExternalAttr},
@@ -372,6 +446,15 @@ Update io_bazel_rules_go to a newer version in your WORKSPACE file.`
 				log.Printf("Found RULES_GO_VERSION %s. Minimum compatible version is %s.\n%s", gc.rulesGoVersion, minimumRulesGoVersion, message)
 			}
 		}
+		repoNamingConvention := map[string]namingConvention{}
+		for _, repo := range c.Repos {
+			if repo.Kind() == "go_repository" {
+				if nc, ok := namingConventionFromString(repo.AttrString("build_naming_convention")); ok {
+					repoNamingConvention[repo.Name()] = nc
+				}
+			}
+		}
+		gc.repoNamingConvention = repoNamingConvention
 	}
 
 	if !gc.moduleMode {
@@ -408,12 +491,15 @@ Update io_bazel_rules_go to a newer version in your WORKSPACE file.`
 				gc.preprocessTags()
 				gc.setBuildTags(d.Value)
 			case "go_generate_proto":
-
 				if goGenerateProto, err := strconv.ParseBool(d.Value); err == nil {
 					gc.goGenerateProto = goGenerateProto
 				} else {
 					log.Printf("parsing go_generate_proto: %v", err)
 				}
+			case "go_naming_convention":
+				if err := gc.setNamingConvention(d.Value); err != nil {
+					log.Print(err)
+				}
 			case "go_grpc_compilers":
 				// Special syntax (empty value) to reset directive.
 				if d.Value == "" {

language/go/config_test.go

@@ -64,6 +64,7 @@ func TestCommandLine(t *testing.T) {
 		t,
 		"-build_tags=foo,bar",
 		"-go_prefix=example.com/repo",
+		"-go_naming_convention=import_alias",
 		"-external=vendored",
 		"-repo_root=.")
 	gc := getGoConfig(c)
@@ -78,6 +79,9 @@ func TestCommandLine(t *testing.T) {
 	if gc.depMode != vendorMode {
 		t.Errorf("got dep mode %v; want %v", gc.depMode, vendorMode)
 	}
+	if gc.goNamingConvention != importAliasNC {
+		t.Errorf("got naming convention %v; want %v", gc.goNamingConvention, importAliasNC)
+	}
 }
 
 func TestDirectives(t *testing.T) {