feat(sidekick/swift): PascalCase naming (#5085)

The Swift naming convention for types is `PascalCase`. This PR
introduces a function to convert names to that style, taking care of the
names that conflict with Swift keywords.

There are corner cases around names that are ALL CAPS, or start with ALL
CAPS. These are more prevalent than one may believe in Google Cloud, so
it is worthwhile having the extra code for them.

Author: coryan

internal/sidekick/swift/names.go

@@ -16,6 +16,8 @@ package swift
 
 import (
 	"fmt"
+	"strings"
+	"unicode"
 
 	"github.com/iancoleman/strcase"
 )
@@ -152,6 +154,28 @@ func escapeKeyword(s string) string {
 	return s
 }
 
+// camelCase converts an identifier to camelCase (note the leading lowercase) and, if needed, escapes it.
+//
+// This function is used for field names and method names, where the Swift style is `camelCase`.
 func camelCase(s string) string {
 	return escapeKeyword(strcase.ToLowerCamel(s))
 }
+
+// pascalCase converts an identifier to PascalCase (note the leading uppercase) and, if needed, escapes it.
+//
+// This function is used for services, messages, and enums, where the Swift style is `PascalCase`.
+func pascalCase(s string) string {
+	// In Swift, it is conventional to preserve ALL CAPS names:
+	//     https://www.swift.org/documentation/api-design-guidelines/#conventions
+	if strings.ToUpper(s) == s {
+		return escapeKeyword(s)
+	}
+	// Symbols that are already `PascalCase` should need no mapping. This works
+	// better than calling `strcase.ToCamel()` in cases like `IAMPolicy`, which
+	// would be converted to `Iampolicy`. We are trusting that the original
+	// name in API definition chose to keep the acronym for a reason.
+	if unicode.IsUpper(rune(s[0])) && !strings.ContainsRune(s, '_') {
+		return escapeKeyword(s)
+	}
+	return escapeKeyword(strcase.ToCamel(s))
+}

internal/sidekick/swift/names_test.go

@@ -16,6 +16,8 @@ package swift
 
 import (
 	"testing"
+
+	"github.com/google/go-cmp/cmp"
 )
 
 func TestEscapeKeyword(t *testing.T) {
@@ -66,8 +68,33 @@ func TestCamelCase(t *testing.T) {
 	} {
 		t.Run(test.input, func(t *testing.T) {
 			got := camelCase(test.input)
-			if got != test.want {
-				t.Errorf("camelCase(%q) = %q, want %q", test.input, got, test.want)
+			if diff := cmp.Diff(test.want, got); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestPascalCase(t *testing.T) {
+	for _, test := range []struct {
+		input string
+		want  string
+	}{
+		{input: "SecretManagerService", want: "SecretManagerService"},
+		{input: "CreateSecretRequest", want: "CreateSecretRequest"},
+		{input: "IAMPolicy", want: "IAMPolicy"},
+		{input: "IAM", want: "IAM"},
+
+		// Keywords that should be escaped after pascalCase
+		{input: "Protocol", want: "Protocol_"},
+		{input: "Type", want: "Type_"},
+		{input: "Self", want: "`Self`"},
+		{input: "Any", want: "`Any`"},
+	} {
+		t.Run(test.input, func(t *testing.T) {
+			got := pascalCase(test.input)
+			if diff := cmp.Diff(test.want, got); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
 			}
 		})
 	}