Initial starlarkbundle lang

Author: pcj

cmd/gazelle/BUILD.bazel

@@ -29,7 +29,7 @@ go_library(
         "//cmd/gazelle/internal/wspace",
         "//language/proto_go_modules",
         "//language/protobuf",
-        "//language/symbol",
+        "//language/starlarkbundle",
         "@bazel_gazelle//config:go_default_library",
         "@bazel_gazelle//flag:go_default_library",
         "@bazel_gazelle//label:go_default_library",

cmd/gazelle/langs.go

@@ -21,13 +21,13 @@ import (
 	"github.com/bazelbuild/bazel-gazelle/language/proto"
 	"github.com/stackb/rules_proto/language/proto_go_modules"
 	"github.com/stackb/rules_proto/language/protobuf"
-	"github.com/stackb/rules_proto/language/symbol"
+	"github.com/stackb/rules_proto/language/starlarkbundle"
 )
 
 var languages = []language.Language{
 	proto.NewLanguage(),
 	protobuf.NewLanguage(),
 	golang.NewLanguage(),
 	proto_go_modules.NewLanguage(),
-	symbol.NewLanguage(),
+	starlarkbundle.NewLanguage(),
 }

language/symbol/BUILD.bazel language/starlarkbundle/BUILD.bazellanguage/symbol/BUILD.bazel renamed to language/starlarkbundle/BUILD.bazel

@@ -1,9 +1,12 @@
 load("@io_bazel_rules_go//go:def.bzl", "go_library")
 
 go_library(
-    name = "symbol",
-    srcs = ["symbol.go"],
-    importpath = "github.com/stackb/rules_proto/language/symbol",
+    name = "starlarkbundle",
+    srcs = [
+        "language.go",
+        "starlark_library.go",
+    ],
+    importpath = "github.com/stackb/rules_proto/language/starlarkbundle",
     visibility = ["//visibility:public"],
     deps = [
         "@bazel_gazelle//config:go_default_library",

language/starlarkbundle/language.go

@@ -0,0 +1,174 @@
+/* Copyright 2020 The Bazel Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package symbol generates a `starlark_library` target for every `.bzl` file in
+// each package.  At the root of the module, a single starlark_bundle is
+// populated with deps that include all other starlark_libraries.
+//
+// The original code for this gazelle extension started from
+// https://github.com/bazelbuild/bazel-skylib/blob/main/gazelle/bzl/gazelle.go.
+package starlarkbundle
+
+import (
+	"flag"
+	"log"
+	"maps"
+
+	"github.com/bazelbuild/bazel-gazelle/config"
+	"github.com/bazelbuild/bazel-gazelle/label"
+	"github.com/bazelbuild/bazel-gazelle/language"
+	"github.com/bazelbuild/bazel-gazelle/repo"
+	"github.com/bazelbuild/bazel-gazelle/resolve"
+	"github.com/bazelbuild/bazel-gazelle/rule"
+)
+
+const (
+	languageName                    = "starlark_bundle"
+	starlarkBundleRootDirectiveName = "starlark_bundle_root"
+)
+
+type starlarkBundleLang struct {
+	starlarkBundleRoot *string
+	starlarkLibraries  map[label.Label]*rule.Rule
+}
+
+// NewLanguage is called by Gazelle to install this language extension in a
+// binary.
+func NewLanguage() language.Language {
+	return &starlarkBundleLang{
+		starlarkLibraries: make(map[label.Label]*rule.Rule),
+	}
+}
+
+// Name returns the name of the language. This should be a prefix of the kinds
+// of rules generated by the language, e.g., "go" for the Go extension since it
+// generates "go_library" rules.
+func (*starlarkBundleLang) Name() string {
+	return languageName
+}
+
+// The following methods are implemented to satisfy the
+// https://pkg.go.dev/github.com/bazelbuild/bazel-gazelle/resolve?tab=doc#Resolver
+// interface, but are otherwise unused.
+func (l *starlarkBundleLang) RegisterFlags(fs *flag.FlagSet, cmd string, c *config.Config) {
+}
+
+func (*starlarkBundleLang) CheckFlags(fs *flag.FlagSet, c *config.Config) error {
+	return nil
+}
+
+func (*starlarkBundleLang) KnownDirectives() []string {
+	return []string{starlarkBundleRootDirectiveName}
+}
+
+func (l *starlarkBundleLang) Configure(c *config.Config, rel string, f *rule.File) {
+	if f != nil {
+		for _, d := range f.Directives {
+			if d.Key == starlarkBundleRootDirectiveName {
+				if l.starlarkBundleRoot != nil {
+					log.Fatalf("gazelle:%s should only be set once (refusing to override %q with %q)", starlarkBundleRootDirectiveName, *l.starlarkBundleRoot, d.Value)
+				}
+				l.starlarkBundleRoot = &rel
+			}
+		}
+	}
+}
+
+// Kinds returns a map of maps rule names (kinds) and information on how to
+// match and merge attributes that may be found in rules of those kinds. All
+// kinds of rules generated for this language may be found here.
+func (*starlarkBundleLang) Kinds() map[string]rule.KindInfo {
+	kinds := map[string]rule.KindInfo{}
+	maps.Copy(kinds, starlarkLibraryKindInfo)
+	return kinds
+}
+
+// Loads returns .bzl files and symbols they define. Every rule generated by
+// GenerateRules, now or in the past, should be loadable from one of these
+// files.
+func (*starlarkBundleLang) Loads() []rule.LoadInfo {
+	return []rule.LoadInfo{
+		starlarkLibraryLoadInfo,
+	}
+}
+
+// Fix repairs deprecated usage of language-specific rules in f. This is called
+// before the file is indexed. Unless c.ShouldFix is true, fixes that delete or
+// rename rules should not be performed.
+func (*starlarkBundleLang) Fix(c *config.Config, f *rule.File) {
+}
+
+// Imports returns a list of ImportSpecs that can be used to import the rule r.
+// This is used to populate RuleIndex.
+//
+// If nil is returned, the rule will not be indexed. If any non-nil slice is
+// returned, including an empty slice, the rule will be indexed.
+func (b *starlarkBundleLang) Imports(c *config.Config, r *rule.Rule, f *rule.File) []resolve.ImportSpec {
+	switch r.Kind() {
+	case starlarkLibraryKind:
+		return starlarkLibraryImports(c, r, f)
+	}
+	return nil
+}
+
+// Embeds returns a list of labels of rules that the given rule embeds. If a
+// rule is embedded by another importable rule of the same language, only the
+// embedding rule will be indexed. The embedding rule will inherit the imports
+// of the embedded rule. Since SkyLark doesn't support embedding this should
+// always return nil.
+func (*starlarkBundleLang) Embeds(r *rule.Rule, from label.Label) []label.Label {
+	return nil
+}
+
+// Resolve translates imported libraries for a given rule into Bazel
+// dependencies. Information about imported libraries is returned for each rule
+// generated by language.GenerateRules in language.GenerateResult.Imports.
+// Resolve generates a "deps" attribute (or the appropriate language-specific
+// equivalent) for each import according to language-specific rules and
+// heuristics.
+func (*starlarkBundleLang) Resolve(c *config.Config, ix *resolve.RuleIndex, rc *repo.RemoteCache, r *rule.Rule, importsRaw interface{}, from label.Label) {
+	switch r.Kind() {
+	case starlarkLibraryKind:
+		starlarkLibraryResolve(c, ix, rc, r, importsRaw, from)
+	}
+}
+
+// GenerateRules extracts build metadata from source files in a directory.
+// GenerateRules is called in each directory where an update is requested in
+// depth-first post-order.
+//
+// args contains the arguments for GenerateRules. This is passed as a struct to
+// avoid breaking implementations in the future when new fields are added.
+//
+// A GenerateResult struct is returned. Optional fields may be added to this
+// type in the future.
+//
+// Any non-fatal errors this function encounters should be logged using
+// log.Print.
+func (l *starlarkBundleLang) GenerateRules(args language.GenerateArgs) (result language.GenerateResult) {
+	if l.starlarkBundleRoot == nil {
+		return
+	}
+
+	for _, r := range []language.GenerateResult{
+		starlarkLibararyGenerate(args),
+	} {
+		result.Gen = append(result.Gen, r.Gen...)
+		result.Imports = append(result.Imports, r.Imports...)
+		result.Empty = append(result.Empty, r.Empty...)
+	}
+
+	return
+}