From 8cee64584adcd142ef59764073cfba22803b06d1 Mon Sep 17 00:00:00 2001 From: Carlos O'Ryan Date: Fri, 20 Nov 2026 12:46:19 +0000 Subject: [PATCH 1/2] refactor(sidekick/api): add (*API).Filter Add a generic (*API).Filter method to construct a filtered copy of an API surface, keeping Rust/prost-specific reachability rules in internal/librarian/rust/generate_prost_hybrid.go. Part of #7837 --- .../librarian/rust/generate_prost_hybrid.go | 80 +--------- internal/sidekick/api/filter.go | 121 +++++++++++++++ internal/sidekick/api/filter_test.go | 146 ++++++++++++++++++ 3 files changed, 273 insertions(+), 74 deletions(-) create mode 100644 internal/sidekick/api/filter.go create mode 100644 internal/sidekick/api/filter_test.go diff --git a/internal/librarian/rust/generate_prost_hybrid.go b/internal/librarian/rust/generate_prost_hybrid.go index fd9cc67cbb..e790aa4d69 100644 --- a/internal/librarian/rust/generate_prost_hybrid.go +++ b/internal/librarian/rust/generate_prost_hybrid.go @@ -15,7 +15,6 @@ package rust import ( - "cmp" "context" "errors" "fmt" @@ -26,7 +25,6 @@ import ( "github.com/googleapis/librarian/internal/config" "github.com/googleapis/librarian/internal/sidekick/api" - "github.com/googleapis/librarian/internal/sidekick/language" "github.com/googleapis/librarian/internal/sidekick/parser" sidekickrust "github.com/googleapis/librarian/internal/sidekick/rust" "github.com/googleapis/librarian/internal/sidekick/rust_prost" @@ -230,67 +228,12 @@ func filterModelToTypes(model *api.API, rootTypeIDs []string, allowGrpcAnyFields return nil, nil, false, errors.New(strings.TrimSuffix(sb.String(), "\n")) } - // Collect external top-level messages (e.g. google.type.LatLng) referenced by roots. - // We sort external types by ID because model.AllMessages() iterates over a map whose - // iteration order is randomized by the Go runtime. - var externalMessages []*api.Message - for m := range model.AllMessages() { - if m.ID() != "" && reachableMsgs[m.ID()] && !isWKT(m.ID()) && m.ID() != ".google.rpc.Status" && m.Parent() == nil { - if m.Package() != model.PackageName && m.Package() != api.ReservedPackageName { - externalMessages = append(externalMessages, m) - } - } - } - slices.SortFunc(externalMessages, func(a, b *api.Message) int { return cmp.Compare(a.ID(), b.ID()) }) - - // Collect external top-level enums referenced by roots. - var externalEnums []*api.Enum - for e := range model.AllEnums() { - if e.ID() != "" && reachableEnums[e.ID()] && !isWKT(e.ID()) && e.Parent() == nil { - if e.Package() != model.PackageName && e.Package() != api.ReservedPackageName { - externalEnums = append(externalEnums, e) - } + hybridModel := model.Filter(func(id string) bool { + if id == "" || isWKT(id) || id == ".google.rpc.Status" { + return false } - } - slices.SortFunc(externalEnums, func(a, b *api.Enum) int { return cmp.Compare(a.ID(), b.ID()) }) - - // Construct hybridModel for prost conversion code generation. - hybridModel := api.API{ - Name: model.Name, - PackageName: model.PackageName, - Title: model.Title, - Description: model.Description, - Revision: model.Revision, - Services: cloneServices(model.Services), - Messages: language.FilterSlice(model.Messages, func(m *api.Message) bool { return reachableMsgs[m.ID()] }), - ExternalMessages: externalMessages, - Enums: language.FilterSlice(model.Enums, func(e *api.Enum) bool { return reachableEnums[e.ID()] }), - ExternalEnums: externalEnums, - ResourceDefinitions: model.ResourceDefinitions, - QuickstartService: model.QuickstartService, - Codec: model.Codec, - } - for _, s := range hybridModel.Services { - hybridModel.AddService(s) - for _, m := range s.Methods() { - hybridModel.AddMethod(m) - } - } - // Populate messageByID and enumByID with ALL package messages and enums. - // This avoids aliasing model.messageByID while allowing model - // annotation to resolve field types across the entire package. - for m := range model.AllMessages() { - hybridModel.AddMessage(m) - } - for e := range model.AllEnums() { - hybridModel.AddEnum(e) - } - for m := range model.AllMaps() { - hybridModel.AddMap(m) - } - for _, r := range hybridModel.ResourceDefinitions { - hybridModel.AddResource(r) - } + return reachableMsgs[id] || reachableEnums[id] + }) var unusedTypes []string for m := range model.AllMessages() { @@ -305,7 +248,7 @@ func filterModelToTypes(model *api.API, rootTypeIDs []string, allowGrpcAnyFields } slices.Sort(unusedTypes) - return &hybridModel, slices.Compact(unusedTypes), hasGoogleRpcStatus, nil + return hybridModel, slices.Compact(unusedTypes), hasGoogleRpcStatus, nil } func isAnyType(id string) bool { @@ -319,14 +262,3 @@ func isGoogleRpcStatus(id string) bool { func isWKT(id string) bool { return strings.HasPrefix(strings.TrimPrefix(id, "."), "google.protobuf.") } - -func cloneServices(services []*api.Service) []*api.Service { - if services == nil { - return nil - } - cloned := make([]*api.Service, len(services)) - for i, s := range services { - cloned[i] = s.Clone() - } - return cloned -} diff --git a/internal/sidekick/api/filter.go b/internal/sidekick/api/filter.go new file mode 100644 index 0000000000..61c5222317 --- /dev/null +++ b/internal/sidekick/api/filter.go @@ -0,0 +1,121 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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 api + +import ( + "cmp" + "slices" +) + +// Filter returns a shallow copy of the API containing cloned services and only +// the top-level messages, enums, and external types whose IDs satisfy keep. +// If keep is nil, all types are retained. +// +// Lookup maps on the returned API retain all messages, enums, maps, and +// resources from the receiver so cross-type references continue to resolve +// without aliasing the receiver's maps. +func (a *API) Filter(keep func(id string) bool) *API { + if a == nil { + return nil + } + if keep == nil { + keep = func(string) bool { return true } + } + + var filteredMsgs []*Message + for _, m := range a.Messages { + if keep(m.ID()) { + filteredMsgs = append(filteredMsgs, m) + } + } + var filteredEnums []*Enum + for _, e := range a.Enums { + if keep(e.ID()) { + filteredEnums = append(filteredEnums, e) + } + } + + // Collect external top-level types satisfying keep, sorted by ID because + // AllMessages/AllEnums iterate over maps in randomized order. + var externalMessages []*Message + for m := range a.AllMessages() { + if m.ID() != "" && m.Parent() == nil && m.Package() != a.PackageName && m.Package() != ReservedPackageName && keep(m.ID()) { + externalMessages = append(externalMessages, m) + } + } + slices.SortFunc(externalMessages, func(x, y *Message) int { return cmp.Compare(x.ID(), y.ID()) }) + + var externalEnums []*Enum + for e := range a.AllEnums() { + if e.ID() != "" && e.Parent() == nil && e.Package() != a.PackageName && e.Package() != ReservedPackageName && keep(e.ID()) { + externalEnums = append(externalEnums, e) + } + } + slices.SortFunc(externalEnums, func(x, y *Enum) int { return cmp.Compare(x.ID(), y.ID()) }) + + var services []*Service + quickstart := a.QuickstartService + if a.Services != nil { + services = make([]*Service, len(a.Services)) + for i, s := range a.Services { + services[i] = s.Clone() + if s == a.QuickstartService { + quickstart = services[i] + } + } + } + + filtered := &API{ + Name: a.Name, + PackageName: a.PackageName, + Title: a.Title, + Description: a.Description, + Revision: a.Revision, + Services: services, + Messages: filteredMsgs, + ExternalMessages: externalMessages, + Enums: filteredEnums, + ExternalEnums: externalEnums, + ResourceDefinitions: slices.Clone(a.ResourceDefinitions), + QuickstartService: quickstart, + RubyPackage: a.RubyPackage, + PhpNamespace: a.PhpNamespace, + CsharpNamespace: a.CsharpNamespace, + } + for _, s := range services { + s.model = filtered + filtered.AddService(s) + for _, m := range s.Methods() { + m.model = filtered + filtered.AddMethod(m) + } + } + // Populate lookup maps with all package messages, enums, maps, and + // resources to avoid aliasing a's maps while still resolving field types + // across excluded top-level elements. + for m := range a.AllMessages() { + filtered.AddMessage(m) + } + for e := range a.AllEnums() { + filtered.AddEnum(e) + } + for m := range a.AllMaps() { + filtered.AddMap(m) + } + for _, r := range filtered.ResourceDefinitions { + filtered.AddResource(r) + } + return filtered +} diff --git a/internal/sidekick/api/filter_test.go b/internal/sidekick/api/filter_test.go new file mode 100644 index 0000000000..1ce536f10f --- /dev/null +++ b/internal/sidekick/api/filter_test.go @@ -0,0 +1,146 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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 api + +import ( + "slices" + "testing" + + "github.com/google/go-cmp/cmp" +) + +func TestAPI_Filter_Nil(t *testing.T) { + if (*API)(nil).Filter(func(string) bool { return true }) != nil { + t.Errorf("(*API)(nil).Filter() should return nil") + } + + m1 := NewTestMessage("M1") + e1 := NewTestEnum("E1") + extM1 := NewTestMessage("ExtM1").WithPackage("google.type") + extE1 := NewTestEnum("ExtE1").WithPackage("google.type") + + model := NewTestAPI([]*Message{m1}, []*Enum{e1}, nil) + model.AddMessage(extM1) + model.AddEnum(extE1) + + got := model.Filter(nil) + if diff := cmp.Diff([]*Message{m1}, got.Messages, allowUnexported()); diff != "" { + t.Errorf("Messages mismatch (-want +got):\n%s", diff) + } + if diff := cmp.Diff([]*Enum{e1}, got.Enums, allowUnexported()); diff != "" { + t.Errorf("Enums mismatch (-want +got):\n%s", diff) + } + if !slices.Contains(got.ExternalMessages, extM1) || !slices.Contains(got.ExternalMessages, model.Message(".google.protobuf.Any")) { + t.Errorf("ExternalMessages = %v, want extM1 and pre-registered external messages retained", got.ExternalMessages) + } + if !slices.Contains(got.ExternalEnums, extE1) || !slices.Contains(got.ExternalEnums, model.Enum(".google.protobuf.NullValue")) { + t.Errorf("ExternalEnums = %v, want extE1 and pre-registered external enums retained", got.ExternalEnums) + } +} + +func TestAPI_Filter(t *testing.T) { + m1 := NewTestMessage("M1") + m2 := NewTestMessage("M2") + e1 := NewTestEnum("E1") + e2 := NewTestEnum("E2") + extM1 := NewTestMessage("ExtM1").WithPackage("google.type") + extM2 := NewTestMessage("ExtM2").WithPackage("google.type") + extE1 := NewTestEnum("ExtE1").WithPackage("google.type") + extE2 := NewTestEnum("ExtE2").WithPackage("google.type") + meth1 := NewTestMethod("Method1").WithInput(m1).WithOutput(m1) + s1 := NewTestService("S1").WithMethods(meth1) + s2 := NewTestService("S2") + res := NewTestResource("test.googleapis.com/Book") + mapType := NewTestMap("AttributesEntry", TypezString, TypezString) + + model := NewTestAPI([]*Message{m1, m2}, []*Enum{e1, e2}, []*Service{s1, s2}) + model.Name = "testapi" + model.Title = "Test API" + model.Description = "Test API description" + model.Revision = "2026-01-01" + model.RubyPackage = "Test::Api" + model.PhpNamespace = "Test\\Api" + model.CsharpNamespace = "Test.Api" + model.QuickstartService = s1 + model.Codec = "orig-codec" + model.ResourceDefinitions = []*Resource{res} + s1.SetAnnotations("svc-codec") + model.AddMessage(extM1) + model.AddMessage(extM2) + model.AddEnum(extE1) + model.AddEnum(extE2) + model.AddMap(mapType) + model.AddResource(res) + + filtered := model.Filter(func(id string) bool { + return id == m1.ID() || id == e1.ID() || id == extM1.ID() || id == extE1.ID() + }) + + if len(filtered.Messages) != 1 || filtered.Messages[0] != m1 { + t.Errorf("got Messages = %v, want [%v]", filtered.Messages, m1) + } + if len(filtered.Enums) != 1 || filtered.Enums[0] != e1 { + t.Errorf("got Enums = %v, want [%v]", filtered.Enums, e1) + } + if len(filtered.ExternalMessages) != 1 || filtered.ExternalMessages[0] != extM1 { + t.Errorf("got ExternalMessages = %v, want [%v]", filtered.ExternalMessages, extM1) + } + if len(filtered.ExternalEnums) != 1 || filtered.ExternalEnums[0] != extE1 { + t.Errorf("got ExternalEnums = %v, want [%v]", filtered.ExternalEnums, extE1) + } + if got := filtered.Message(m2.ID()); got != m2 { + t.Errorf("filtered.Message(%q) = %v, want %v", m2.ID(), got, m2) + } + if got := filtered.Enum(e2.ID()); got != e2 { + t.Errorf("filtered.Enum(%q) = %v, want %v", e2.ID(), got, e2) + } + if got := filtered.Map(mapType.ID()); got != mapType { + t.Errorf("filtered.Map(%q) = %v, want %v", mapType.ID(), got, mapType) + } + if got := filtered.Resource(res.Type()); got != res { + t.Errorf("filtered.Resource(%q) = %v, want %v", res.Type(), got, res) + } + if filtered.Codec != nil { + t.Errorf("filtered.Codec = %v, want nil", filtered.Codec) + } + + services := filtered.Services + if len(services) != 2 { + t.Fatalf("len(filtered.Services) = %d, want 2", len(services)) + } + if services[0] == s1 || services[0].Codec() != nil { + t.Errorf("cloned service did not preserve Clone() semantics") + } + if filtered.QuickstartService != services[0] { + t.Errorf("filtered.QuickstartService = %v, want %v", filtered.QuickstartService, services[0]) + } + if services[0].Model() != filtered { + t.Errorf("services[0].Model() = %v, want %v", services[0].Model(), filtered) + } + methods := services[0].Methods() + if len(methods) != 1 || methods[0].Model() != filtered { + t.Errorf("cloned method Model() = %v, want %v", methods[0].Model(), filtered) + } + if filtered.Name != model.Name || + filtered.PackageName != model.PackageName || + filtered.Title != model.Title || + filtered.Description != model.Description || + filtered.Revision != model.Revision || + filtered.RubyPackage != model.RubyPackage || + filtered.PhpNamespace != model.PhpNamespace || + filtered.CsharpNamespace != model.CsharpNamespace { + t.Errorf("API metadata was not preserved: got %+v", filtered) + } +} From b07ca8892b0dc38512ba4d192bbbd58e9c8d8a84 Mon Sep 17 00:00:00 2001 From: Carlos O'Ryan Date: Fri, 20 Nov 2026 19:37:59 +0000 Subject: [PATCH 2/2] fix(sidekick/api): copy all resources in Filter --- internal/sidekick/api/filter.go | 8 ++++---- internal/sidekick/api/filter_test.go | 9 +++++++-- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/internal/sidekick/api/filter.go b/internal/sidekick/api/filter.go index 61c5222317..6cfad0cf49 100644 --- a/internal/sidekick/api/filter.go +++ b/internal/sidekick/api/filter.go @@ -19,9 +19,9 @@ import ( "slices" ) -// Filter returns a shallow copy of the API containing cloned services and only -// the top-level messages, enums, and external types whose IDs satisfy keep. -// If keep is nil, all types are retained. +// Filter returns a shallow copy of the API with Codec cleared, cloned services, +// and only the top-level messages, enums, and external types whose IDs satisfy +// keep. If keep is nil, all types are retained. // // Lookup maps on the returned API retain all messages, enums, maps, and // resources from the receiver so cross-type references continue to resolve @@ -114,7 +114,7 @@ func (a *API) Filter(keep func(id string) bool) *API { for m := range a.AllMaps() { filtered.AddMap(m) } - for _, r := range filtered.ResourceDefinitions { + for r := range a.AllResources() { filtered.AddResource(r) } return filtered diff --git a/internal/sidekick/api/filter_test.go b/internal/sidekick/api/filter_test.go index 1ce536f10f..e2130ac4bb 100644 --- a/internal/sidekick/api/filter_test.go +++ b/internal/sidekick/api/filter_test.go @@ -37,10 +37,10 @@ func TestAPI_Filter_Nil(t *testing.T) { got := model.Filter(nil) if diff := cmp.Diff([]*Message{m1}, got.Messages, allowUnexported()); diff != "" { - t.Errorf("Messages mismatch (-want +got):\n%s", diff) + t.Errorf("mismatch (-want +got):\n%s", diff) } if diff := cmp.Diff([]*Enum{e1}, got.Enums, allowUnexported()); diff != "" { - t.Errorf("Enums mismatch (-want +got):\n%s", diff) + t.Errorf("mismatch (-want +got):\n%s", diff) } if !slices.Contains(got.ExternalMessages, extM1) || !slices.Contains(got.ExternalMessages, model.Message(".google.protobuf.Any")) { t.Errorf("ExternalMessages = %v, want extM1 and pre-registered external messages retained", got.ExternalMessages) @@ -63,6 +63,7 @@ func TestAPI_Filter(t *testing.T) { s1 := NewTestService("S1").WithMethods(meth1) s2 := NewTestService("S2") res := NewTestResource("test.googleapis.com/Book") + msgRes := NewTestResource("test.googleapis.com/Shelf") mapType := NewTestMap("AttributesEntry", TypezString, TypezString) model := NewTestAPI([]*Message{m1, m2}, []*Enum{e1, e2}, []*Service{s1, s2}) @@ -83,6 +84,7 @@ func TestAPI_Filter(t *testing.T) { model.AddEnum(extE2) model.AddMap(mapType) model.AddResource(res) + model.AddResource(msgRes) filtered := model.Filter(func(id string) bool { return id == m1.ID() || id == e1.ID() || id == extM1.ID() || id == extE1.ID() @@ -112,6 +114,9 @@ func TestAPI_Filter(t *testing.T) { if got := filtered.Resource(res.Type()); got != res { t.Errorf("filtered.Resource(%q) = %v, want %v", res.Type(), got, res) } + if got := filtered.Resource(msgRes.Type()); got != msgRes { + t.Errorf("filtered.Resource(%q) = %v, want %v", msgRes.Type(), got, msgRes) + } if filtered.Codec != nil { t.Errorf("filtered.Codec = %v, want nil", filtered.Codec) }