Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
80 changes: 6 additions & 74 deletions internal/librarian/rust/generate_prost_hybrid.go
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,6 @@
package rust

import (
"cmp"
"context"
"errors"
"fmt"
Expand All @@ -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"
Expand Down Expand Up @@ -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() {
Expand All @@ -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 {
Expand All @@ -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
}
121 changes: 121 additions & 0 deletions internal/sidekick/api/filter.go
Original file line number Diff line number Diff line change
@@ -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 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
// 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,
}
Comment thread
coryan marked this conversation as resolved.
Resolved
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 a.AllResources() {
filtered.AddResource(r)
}
return filtered
}
151 changes: 151 additions & 0 deletions internal/sidekick/api/filter_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,151 @@
// 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("mismatch (-want +got):\n%s", diff)
}
if diff := cmp.Diff([]*Enum{e1}, got.Enums, allowUnexported()); diff != "" {
t.Errorf("mismatch (-want +got):\n%s", diff)
}
Comment thread
coryan marked this conversation as resolved.
Resolved
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")
msgRes := NewTestResource("test.googleapis.com/Shelf")
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)
model.AddResource(msgRes)

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 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)
}
Comment thread
coryan marked this conversation as resolved.
Resolved

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)
}
}
Loading