@bufbuild/protobuf 1.8.0 → 2.0.0-alpha.1

package/dist/esm/index.js

@@ -11,33 +11,16 @@
 // 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.
-export { proto3 } from "./proto3.js";
-export { proto2 } from "./proto2.js";
-export { protoDouble } from "./proto-double.js";
-export { protoInt64 } from "./proto-int64.js";
-export { protoBase64 } from "./proto-base64.js";
-export { protoDelimited } from "./proto-delimited.js";
-export { codegenInfo } from "./codegen-info.js";
-export { Message } from "./message.js";
-export { isMessage } from "./is-message.js";
-export { LongType, ScalarType } from "./scalar.js";
-export { getExtension, setExtension, hasExtension, clearExtension, } from "./extension-accessor.js";
-export { MethodKind, MethodIdempotency } from "./service-type.js";
-export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
-export { createDescriptorSet } from "./create-descriptor-set.js";
-export { createRegistry } from "./create-registry.js";
-export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
-export { toPlainMessage } from "./to-plain-message.js";
-// ideally, we would export these types with sub-path exports:
-export * from "./google/protobuf/compiler/plugin_pb.js";
-export * from "./google/protobuf/api_pb.js";
-export * from "./google/protobuf/any_pb.js";
-export * from "./google/protobuf/descriptor_pb.js";
-export * from "./google/protobuf/duration_pb.js";
-export * from "./google/protobuf/empty_pb.js";
-export * from "./google/protobuf/field_mask_pb.js";
-export * from "./google/protobuf/source_context_pb.js";
-export * from "./google/protobuf/struct_pb.js";
-export * from "./google/protobuf/timestamp_pb.js";
-export * from "./google/protobuf/type_pb.js";
-export * from "./google/protobuf/wrappers_pb.js";
+export * from "./types.js";
+export * from "./is-message.js";
+export * from "./create.js";
+export * from "./clone.js";
+export * from "./desc-types.js";
+export * from "./equals.js";
+export * from "./fields.js";
+export { toBinary } from "./to-binary.js";
+export { fromBinary, mergeFromBinary } from "./from-binary.js";
+export * from "./to-json.js";
+export * from "./from-json.js";
+export { hasExtension, getExtension, setExtension, clearExtension, } from "./extensions.js";
+export * from "./proto-int64.js";

package/dist/esm/is-message.d.ts

@@ -1,22 +1,7 @@
-import type { MessageType } from "./message-type.js";
-import type { AnyMessage } from "./message.js";
-import { Message } from "./message.js";
+import type { MessageShape } from "./types.js";
+import type { DescMessage } from "./desc-types.js";
 /**
- * Check whether the given object is any subtype of Message or is a specific
- * Message by passing the type.
- *
- * Just like `instanceof`, `isMessage` narrows the type. The advantage of
- * `isMessage` is that it compares identity by the message type name, not by
- * class identity. This makes it robust against the dual package hazard and
- * similar situations, where the same message is duplicated.
- *
- * This function is _mostly_ equivalent to the `instanceof` operator. For
- * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
- * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
- * `isMessage` should be preferred over `instanceof`.
- *
- * However, due to the fact that `isMessage` does not use class identity, there
- * are subtle differences between this function and `instanceof`. Notably,
- * calling `isMessage` on an explicit type of Message will return false.
+ * Determine whether the given `arg` is a message.
+ * If `desc` is set, determine whether `arg` is this specific message.
  */
-export declare function isMessage<T extends Message<T> = AnyMessage>(arg: unknown, type?: MessageType<T>): arg is T;
+export declare function isMessage<Desc extends DescMessage>(arg: unknown, desc?: Desc): arg is MessageShape<Desc>;

package/dist/esm/is-message.js

@@ -11,38 +11,20 @@
 // 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.
-import { Message } from "./message.js";
 /**
- * Check whether the given object is any subtype of Message or is a specific
- * Message by passing the type.
- *
- * Just like `instanceof`, `isMessage` narrows the type. The advantage of
- * `isMessage` is that it compares identity by the message type name, not by
- * class identity. This makes it robust against the dual package hazard and
- * similar situations, where the same message is duplicated.
- *
- * This function is _mostly_ equivalent to the `instanceof` operator. For
- * example, `isMessage(foo, MyMessage)` is the same as `foo instanceof MyMessage`,
- * and `isMessage(foo)` is the same as `foo instanceof Message`. In most cases,
- * `isMessage` should be preferred over `instanceof`.
- *
- * However, due to the fact that `isMessage` does not use class identity, there
- * are subtle differences between this function and `instanceof`. Notably,
- * calling `isMessage` on an explicit type of Message will return false.
+ * Determine whether the given `arg` is a message.
+ * If `desc` is set, determine whether `arg` is this specific message.
  */
-export function isMessage(arg, type) {
-    if (arg === null || typeof arg != "object") {
+export function isMessage(arg, desc) {
+    const isMessage = arg !== null &&
+        typeof arg == "object" &&
+        "$typeName" in arg &&
+        typeof arg.$typeName == "string";
+    if (!isMessage) {
         return false;
     }
-    if (!Object.getOwnPropertyNames(Message.prototype).every((m) => m in arg && typeof arg[m] == "function")) {
-        return false;
-    }
-    const actualType = arg.getType();
-    if (actualType === null ||
-        typeof actualType != "function" ||
-        !("typeName" in actualType) ||
-        typeof actualType.typeName != "string") {
-        return false;
+    if (desc === undefined) {
+        return true;
     }
-    return type === undefined ? true : actualType.typeName == type.typeName;
+    return desc.typeName === arg.$typeName;
 }

package/dist/esm/json-value.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Represents any possible JSON value:
+ * - number
+ * - string
+ * - boolean
+ * - null
+ * - object (with any JSON value as property)
+ * - array (with any JSON value as element)
+ */
+export type JsonValue = number | string | boolean | null | JsonObject | JsonValue[];
+/**
+ * Represents a JSON object.
+ */
+export type JsonObject = {
+    [k: string]: JsonValue;
+};

package/dist/esm/proto-int64.js

@@ -11,8 +11,8 @@
 // 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.
-import { assert } from "./private/assert.js";
-import { int64FromString, int64ToString, uInt64ToString, } from "./google/varint.js";
+import { assert } from "./reflect/assert.js";
+import { int64FromString, int64ToString, uInt64ToString, } from "./wire/varint.js";
 function makeInt64Support() {
     const dv = new DataView(new ArrayBuffer(8));
     // note that Safari 14 implements BigInt, but not the DataView methods

package/dist/esm/reflect/error.d.ts

@@ -0,0 +1,9 @@
+import type { DescField, DescOneof } from "../desc-types.js";
+declare const errorNames: string[];
+export declare class FieldError extends Error {
+    readonly name: (typeof errorNames)[number];
+    constructor(fieldOrOneof: DescField | DescOneof, message: string, name?: (typeof errorNames)[number]);
+    readonly field: () => DescField | DescOneof;
+}
+export declare function isFieldError(arg: unknown): arg is FieldError;
+export {};

package/dist/esm/reflect/error.js

@@ -0,0 +1,31 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+const errorNames = [
+    "FieldValueInvalidError",
+    "FieldListRangeError",
+    "ForeignFieldError",
+];
+export class FieldError extends Error {
+    constructor(fieldOrOneof, message, name = "FieldValueInvalidError") {
+        super(message);
+        this.name = name;
+        this.field = () => fieldOrOneof;
+    }
+}
+export function isFieldError(arg) {
+    return (arg instanceof Error &&
+        errorNames.includes(arg.name) &&
+        "field" in arg &&
+        typeof arg.field == "function");
+}

package/dist/esm/reflect/guard.d.ts

@@ -0,0 +1,20 @@
+import type { Message } from "../types.js";
+import type { ScalarValue } from "./scalar.js";
+import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
+import type { DescField, DescMessage } from "../desc-types.js";
+export declare function isObject(arg: unknown): arg is Record<string, unknown>;
+export declare function isOneofADT(arg: unknown): arg is OneofADT;
+export type OneofADT = {
+    case: undefined;
+    value?: undefined;
+} | {
+    case: string;
+    value: Message | ScalarValue;
+};
+export declare function isReflectList(arg: unknown, field?: DescField & {
+    fieldKind: "list";
+}): arg is ReflectList;
+export declare function isReflectMap(arg: unknown, field?: DescField & {
+    fieldKind: "map";
+}): arg is ReflectMap;
+export declare function isReflectMessage(arg: unknown, messageDesc?: DescMessage): arg is ReflectMessage;

package/dist/esm/reflect/guard.js

@@ -0,0 +1,70 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+import { unsafeLocal } from "./unsafe.js";
+import { isMessage } from "../is-message.js";
+export function isObject(arg) {
+    return arg !== null && typeof arg == "object" && !Array.isArray(arg);
+}
+export function isOneofADT(arg) {
+    return (arg !== null &&
+        typeof arg == "object" &&
+        "case" in arg &&
+        ((typeof arg.case == "string" && "value" in arg && arg.value != null) ||
+            (arg.case === undefined &&
+                (!("value" in arg) || arg.value === undefined))));
+}
+export function isReflectList(arg, field) {
+    var _a, _b, _c, _d;
+    if (isObject(arg) &&
+        unsafeLocal in arg &&
+        "add" in arg &&
+        "field" in arg &&
+        typeof arg.field == "function") {
+        if (field !== undefined) {
+            const a = field, b = arg.field();
+            return (a.listKind == b.listKind &&
+                a.scalar === b.scalar &&
+                ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) &&
+                ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName));
+        }
+        return true;
+    }
+    return false;
+}
+export function isReflectMap(arg, field) {
+    var _a, _b, _c, _d;
+    if (isObject(arg) &&
+        unsafeLocal in arg &&
+        "has" in arg &&
+        "field" in arg &&
+        typeof arg.field == "function") {
+        if (field !== undefined) {
+            const a = field, b = arg.field();
+            return (a.mapKey === b.mapKey &&
+                a.mapKind == b.mapKind &&
+                a.scalar === b.scalar &&
+                ((_a = a.message) === null || _a === void 0 ? void 0 : _a.typeName) === ((_b = b.message) === null || _b === void 0 ? void 0 : _b.typeName) &&
+                ((_c = a.enum) === null || _c === void 0 ? void 0 : _c.typeName) === ((_d = b.enum) === null || _d === void 0 ? void 0 : _d.typeName));
+        }
+        return true;
+    }
+    return false;
+}
+export function isReflectMessage(arg, messageDesc) {
+    return (isObject(arg) &&
+        unsafeLocal in arg &&
+        "message" in arg &&
+        isMessage(arg.message) &&
+        (messageDesc === undefined || arg.message.$typeName == messageDesc.typeName));
+}

package/dist/esm/reflect/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./error.js";
+export * from "./names.js";
+export * from "./nested-types.js";
+export * from "./reflect.js";
+export * from "./reflect-types.js";
+export * from "./registry.js";
+export * from "./scalar.js";
+export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";

package/dist/esm/reflect/index.js

@@ -0,0 +1,21 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+export * from "./error.js";
+export * from "./names.js";
+export * from "./nested-types.js";
+export * from "./reflect.js";
+export * from "./reflect-types.js";
+export * from "./registry.js";
+export * from "./scalar.js";
+export { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";

package/dist/esm/reflect/names.d.ts

@@ -0,0 +1,23 @@
+import type { DescEnumValue, DescField } from "../desc-types.js";
+import type { DescMethod, DescOneof } from "../desc-types.js";
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For methods,
+ * the first character is made lowercase. All names are escaped to be safe object
+ * property names.
+ *
+ * This function does not provide names for messages, enumerations, and services.
+ */
+export declare function localName(desc: DescEnumValue | DescOneof | DescField | DescMethod): string;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+export declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin/ecmascript.
+ */
+export declare function safeObjectProperty(name: string): string;

package/dist/esm/reflect/names.js

@@ -0,0 +1,106 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For methods,
+ * the first character is made lowercase. All names are escaped to be safe object
+ * property names.
+ *
+ * This function does not provide names for messages, enumerations, and services.
+ */
+export function localName(desc) {
+    const name = desc.name;
+    switch (desc.kind) {
+        // @ts-expect-error TS7029
+        case "field":
+            if (desc.oneof !== undefined) {
+                // oneof member names are not properties, but values of the `case` property.
+                return protoCamelCase(name);
+            }
+        // eslint-disable-next-line no-fallthrough
+        case "oneof":
+            return safeObjectProperty(protoCamelCase(name));
+        case "enum_value": {
+            let name = desc.name;
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix !== undefined) {
+                name = name.substring(sharedPrefix.length);
+            }
+            return safeObjectProperty(name);
+        }
+        case "rpc": {
+            if (name.length == 0) {
+                return name;
+            }
+            return safeObjectProperty(name[0].toLowerCase() + name.substring(1));
+        }
+    }
+}
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+export function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin/ecmascript.
+ */
+export function safeObjectProperty(name) {
+    return reservedObjectProperties.has(name) ? name + "$" : name;
+}

package/dist/esm/reflect/nested-types.d.ts

@@ -0,0 +1,2 @@
+import type { DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../desc-types.js";
+export declare function nestedTypes(desc: DescFile | DescMessage): Iterable<DescMessage | DescEnum | DescExtension | DescService>;

package/dist/esm/reflect/nested-types.js

@@ -0,0 +1,34 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+export function* nestedTypes(desc) {
+    switch (desc.kind) {
+        case "file":
+            for (const message of desc.messages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.enums;
+            yield* desc.services;
+            yield* desc.extensions;
+            break;
+        case "message":
+            for (const message of desc.nestedMessages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.nestedEnums;
+            yield* desc.nestedExtensions;
+            break;
+    }
+}

package/dist/esm/reflect/reflect-check.d.ts

@@ -0,0 +1,10 @@
+import type { DescField } from "../desc-types.js";
+import { FieldError } from "./error.js";
+export declare function checkField(field: DescField, value: unknown): FieldError | undefined;
+export declare function checkListItem(field: DescField & {
+    fieldKind: "list";
+}, index: number, value: unknown): FieldError | undefined;
+export declare function checkMapEntry(field: DescField & {
+    fieldKind: "map";
+}, key: unknown, value: unknown): FieldError | undefined;
+export declare function formatVal(val: unknown): string;

package/dist/esm/reflect/reflect-check.js

@@ -0,0 +1,143 @@
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// 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.
+import { ScalarType, scalarTypeDescription } from "./scalar.js";
+import { checkScalarValue } from "./scalar.js";
+import { isMessage } from "../is-message.js";
+import { FieldError } from "./error.js";
+import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
+export function checkField(field, value) {
+    const check = field.fieldKind == "list"
+        ? isReflectList(value, field)
+        : field.fieldKind == "map"
+            ? isReflectMap(value, field)
+            : checkSingular(field, value);
+    if (check === true) {
+        return undefined;
+    }
+    let reason;
+    switch (field.fieldKind) {
+        case "list":
+            reason = `expected ${formatReflectList(field)}, got ${formatVal(value)}`;
+            break;
+        case "map":
+            reason = `expected ${formatReflectMap(field)}, got ${formatVal(value)}`;
+            break;
+        default: {
+            reason = reasonSingular(field, value, check);
+        }
+    }
+    return new FieldError(field, reason);
+}
+export function checkListItem(field, index, value) {
+    const check = checkSingular(field, value);
+    if (check !== true) {
+        return new FieldError(field, `list item #${index + 1}: ${reasonSingular(field, value, check)}`);
+    }
+    return undefined;
+}
+export function checkMapEntry(field, key, value) {
+    const checkKey = checkScalarValue(key, field.mapKey);
+    if (checkKey !== true) {
+        return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+    }
+    const checkVal = checkSingular(field, value);
+    if (checkVal !== true) {
+        return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+    }
+    return undefined;
+}
+function checkSingular(field, value) {
+    if (field.scalar !== undefined) {
+        return checkScalarValue(value, field.scalar);
+    }
+    if (field.enum !== undefined) {
+        if (field.enum.open) {
+            return Number.isInteger(value);
+        }
+        return field.enum.values.some((v) => v.number === value);
+    }
+    return isReflectMessage(value, field.message);
+}
+function reasonSingular(field, val, details) {
+    details =
+        typeof details == "string" ? `: ${details}` : `, got ${formatVal(val)}`;
+    if (field.scalar !== undefined) {
+        return `expected ${scalarTypeDescription(field.scalar)}` + details;
+    }
+    else if (field.enum !== undefined) {
+        return `expected ${field.enum.toString()}` + details;
+    }
+    return `expected ${formatReflectMessage(field.message)}` + details;
+}
+export function formatVal(val) {
+    switch (typeof val) {
+        case "object":
+            if (val === null) {
+                return "null";
+            }
+            if (val instanceof Uint8Array) {
+                return `Uint8Array(${val.length})`;
+            }
+            if (Array.isArray(val)) {
+                return `Array(${val.length})`;
+            }
+            if (isReflectList(val)) {
+                return formatReflectList(val.field());
+            }
+            if (isReflectMap(val)) {
+                return formatReflectMap(val.field());
+            }
+            if (isReflectMessage(val)) {
+                return formatReflectMessage(val.desc);
+            }
+            if (isMessage(val)) {
+                return `message ${val.$typeName}`;
+            }
+            return "object";
+        case "string":
+            return val.length > 30 ? "string" : `"${val.split('"').join('\\"')}"`;
+        case "boolean":
+            return String(val);
+        case "number":
+            return String(val);
+        case "bigint":
+            return String(val) + "n";
+        default:
+            // "symbol" | "undefined" | "object" | "function"
+            return typeof val;
+    }
+}
+function formatReflectMessage(desc) {
+    return `ReflectMessage (${desc.typeName})`;
+}
+function formatReflectList(field) {
+    switch (field.listKind) {
+        case "message":
+            return `ReflectList (${field.message.toString()})`;
+        case "enum":
+            return `ReflectList (${field.enum.toString()})`;
+        case "scalar":
+            return `ReflectList (${ScalarType[field.scalar]})`;
+    }
+}
+function formatReflectMap(field) {
+    switch (field.mapKind) {
+        case "message":
+            return `ReflectMap (${ScalarType[field.mapKey]}, ${field.message.toString()})`;
+        case "enum":
+            return `ReflectMap (${ScalarType[field.mapKey]}, ${field.enum.toString()})`;
+        case "scalar":
+            return `ReflectMap (${ScalarType[field.mapKey]}, ${ScalarType[field.scalar]})`;
+    }
+}