feat(internal/config): add language to rust module (#3541)

Add `language`, `specification_format` to rust module config. These two
params need to be override when generating the special storage control
library.

Add the following config to `google-cloud-storage` in google-cloud-rust
after merging this PR:
```
- language: rust_storage
  output: src/storage/src/control/generated
  specification_format: none
```

Fixes #3532

Author: JoeWang1127

internal/config/language.go

@@ -79,6 +79,10 @@ type RustModule struct {
 	// IncludeList is a list of proto files to include (e.g., "date.proto,expr.proto").
 	IncludeList string `yaml:"include_list,omitempty"`
 
+	// Language can be used to select a variation of the Rust generator.
+	// For example, `rust_storage` enables special handling for the storage client.
+	Language string `yaml:"language,omitempty"`
+
 	// ModulePath is the Rust module path for converters
 	// (e.g., "crate::generated::gapic::model").
 	ModulePath string `yaml:"module_path,omitempty"`
@@ -104,6 +108,9 @@ type RustModule struct {
 	// SkippedIds is a list of proto IDs to skip in generation.
 	SkippedIds []string `yaml:"skipped_ids,omitempty"`
 
+	// SpecificationFormat overrides the library-level specification format.
+	SpecificationFormat string `yaml:"specification_format,omitempty"`
+
 	// Source is the proto path to generate from (e.g., "google/storage/v2").
 	Source string `yaml:"source"`
 

internal/librarian/rust/codec.go

@@ -249,13 +249,20 @@ func moduleToSidekickConfig(library *config.Library, module *config.RustModule,
 	}
 
 	language := "rust"
-	if module.Template == "prost" {
+	if module.Language != "" {
+		language = module.Language
+	} else if module.Template == "prost" {
 		language = "rust+prost"
 	}
+
+	specificationFormat := "protobuf"
+	if module.SpecificationFormat != "" {
+		specificationFormat = module.SpecificationFormat
+	}
 	sidekickCfg := &sidekickconfig.Config{
 		General: sidekickconfig.GeneralConfig{
 			Language:            language,
-			SpecificationFormat: "protobuf",
+			SpecificationFormat: specificationFormat,
 			ServiceConfig:       module.ServiceConfig,
 			SpecificationSource: module.Source,
 		},

internal/librarian/rust/codec_test.go

@@ -707,6 +707,62 @@ func TestToSidekickConfig(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "with custom module language",
+			library: &config.Library{
+				Name: "google-cloud-showcase",
+				Rust: &config.RustCrate{
+					Modules: []*config.RustModule{
+						{
+							Language: "rust_storage",
+						},
+					},
+				},
+			},
+			want: &sidekickconfig.Config{
+				General: sidekickconfig.GeneralConfig{
+					Language:            "rust_storage",
+					SpecificationFormat: "protobuf",
+				},
+			},
+		},
+		{
+			name: "with custom module specification format",
+			library: &config.Library{
+				Name: "google-cloud-showcase",
+				Rust: &config.RustCrate{
+					Modules: []*config.RustModule{
+						{
+							SpecificationFormat: "none",
+						},
+					},
+				},
+			},
+			want: &sidekickconfig.Config{
+				General: sidekickconfig.GeneralConfig{
+					Language:            "rust",
+					SpecificationFormat: "none",
+				},
+			},
+		},
+		{
+			name: "with prost as module template",
+			library: &config.Library{
+				Name: "google-cloud-showcase",
+				Rust: &config.RustCrate{
+					Modules: []*config.RustModule{
+						{
+							Template: "prost",
+						},
+					},
+				},
+			},
+			want: &sidekickconfig.Config{
+				General: sidekickconfig.GeneralConfig{
+					Language: "rust+prost",
+				},
+			},
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			if test.library.Rust != nil && test.library.Rust.Modules != nil {

internal/librarian/rust/generate.go

@@ -85,6 +85,8 @@ func generateVeneer(ctx context.Context, library *config.Library, googleapisDir,
 		switch sidekickConfig.General.Language {
 		case "rust":
 			err = sidekickrust.Generate(ctx, model, module.Output, sidekickConfig)
+		case "rust_storage":
+			return generateRustStorage(ctx, library, module.Output, googleapisDir, protobufSrcDir)
 		case "rust+prost":
 			err = rust_prost.Generate(ctx, model, module.Output, sidekickConfig)
 		default:
@@ -150,3 +152,43 @@ func DeriveChannelPath(name string) string {
 func DefaultOutput(channel, defaultOutput string) string {
 	return filepath.Join(defaultOutput, strings.TrimPrefix(channel, "google/"))
 }
+
+// generateRustStorage generates rust StorageControl client.
+//
+// The StorageControl client depends on multiple specification sources.
+// We load them both here, and pass them along to `rust.GenerateStorage` which will merge them appropriately.
+func generateRustStorage(ctx context.Context, library *config.Library, moduleOutput, googleapisDir, protobufSrcDir string) error {
+	output := "src/storage/src/generated/gapic"
+	storageModule := findModuleByOutput(library, output)
+	if storageModule == nil {
+		return fmt.Errorf("could not find module with output %s in library %s", output, library.Name)
+	}
+	storageConfig := moduleToSidekickConfig(library, storageModule, googleapisDir, protobufSrcDir)
+	storageModel, err := parser.CreateModel(storageConfig)
+	if err != nil {
+		return fmt.Errorf("failed to create storage model: %w", err)
+	}
+
+	output = "src/storage/src/generated/gapic_control"
+	controlModule := findModuleByOutput(library, "src/storage/src/generated/gapic_control")
+	if controlModule == nil {
+		return fmt.Errorf("could not find module with output %s in library %s", output, library.Name)
+	}
+	controlConfig := moduleToSidekickConfig(library, controlModule, googleapisDir, protobufSrcDir)
+	controlModel, err := parser.CreateModel(controlConfig)
+	if err != nil {
+		return fmt.Errorf("failed to create control model: %w", err)
+	}
+
+	return sidekickrust.GenerateStorage(ctx, moduleOutput, storageModel, storageConfig, controlModel, controlConfig)
+}
+
+func findModuleByOutput(library *config.Library, output string) *config.RustModule {
+	for _, module := range library.Rust.Modules {
+		if module.Output == output {
+			return module
+		}
+	}
+
+	return nil
+}

internal/librarian/rust/generate_test.go

@@ -302,3 +302,59 @@ func TestDeriveChannelPath(t *testing.T) {
 		})
 	}
 }
+
+func TestFindModuleByOutput(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		lib    *config.Library
+		output string
+		want   *config.RustModule
+	}{
+		{
+			name: "find the module",
+			lib: &config.Library{
+				Name: "test",
+				Rust: &config.RustCrate{
+					Modules: []*config.RustModule{
+						{
+							Language: "target-language",
+							Output:   "target-output",
+						},
+						{
+							Language: "other-language",
+							Output:   "other-output",
+						},
+					},
+				},
+			},
+			output: "target-output",
+			want: &config.RustModule{
+				Language: "target-language",
+				Output:   "target-output",
+			},
+		},
+		{
+			name: "does not find the module",
+			lib: &config.Library{
+				Name: "test",
+				Rust: &config.RustCrate{
+					Modules: []*config.RustModule{
+						{
+							Language: "other-language",
+							Output:   "other-output",
+						},
+					},
+				},
+			},
+			output: "target-output",
+			want:   nil,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := findModuleByOutput(test.lib, test.output)
+			if diff := cmp.Diff(test.want, got); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

internal/sidekick/config/config.go

@@ -23,7 +23,7 @@ import (
 	"path"
 
 	"github.com/googleapis/librarian/internal/sidekick/license"
-	toml "github.com/pelletier/go-toml/v2"
+	"github.com/pelletier/go-toml/v2"
 )
 
 const (