@azure-tools/typespec-go 0.14.2 → 0.15.0-dev.4

package/dist/{typespec-go/src → src}/tcgcadapter/types.js

@@ -2,13 +2,14 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as tcgc from '@azure-tools/typespec-client-generator-core';
-import * as tsp from '@typespec/compiler';
-import * as http from '@typespec/http';
-import * as helpers from './helpers.js';
-import * as go from '../../../codemodel.go/src/index.js';
-import * as naming from '../../../naming.go/src/naming.js';
-import { AdapterError } from '../tcgcadapter/errors.js';
+/* eslint-disable @typescript-eslint/no-deprecated -- uses TCGC APIs marked deprecated (serializedName) as a documented fallback when serializationOptions is empty. */
+import * as tcgc from "@azure-tools/typespec-client-generator-core";
+import * as tsp from "@typespec/compiler";
+import * as http from "@typespec/http";
+import * as go from "../codemodel/index.js";
+import * as naming from "../naming/naming.js";
+import { AdapterError } from "../tcgcadapter/errors.js";
+import * as helpers from "./helpers.js";
 /** used to convert tcgc types to Go code model types */
 export class TypeAdapter {
     /** the SdkContext for this adapter */
@@ -34,7 +35,9 @@ export class TypeAdapter {
      * @returns the module or package to contain the adapted tcgc model
      */
     getPkg() {
-        return this.codeModel.root.kind === 'containingModule' ? this.codeModel.root.package : this.codeModel.root;
+        return this.codeModel.root.kind === "containingModule"
+            ? this.codeModel.root.package
+            : this.codeModel.root;
     }
     /**
      * converts all tcgc model/enum types to Go code model types
@@ -45,7 +48,8 @@ export class TypeAdapter {
                 // skip enums that are used for API version
                 continue;
             }
-            else if ((enumType.usage & tcgc.UsageFlags.Input) === 0 && (enumType.usage & tcgc.UsageFlags.Output) === 0) {
+            else if ((enumType.usage & tcgc.UsageFlags.Input) === 0 &&
+                (enumType.usage & tcgc.UsageFlags.Output) === 0) {
                 // skip types without input and output usage
                 continue;
             }
@@ -61,11 +65,13 @@ export class TypeAdapter {
                 // we don't use these so just skip them.
                 continue;
             }
-            else if (modelType.access === 'internal' && (modelType.usage & tcgc.UsageFlags.Spread) !== 0) {
+            else if (modelType.access === "internal" &&
+                (modelType.usage & tcgc.UsageFlags.Spread) !== 0) {
                 // we don't use the internal models for spread params
                 continue;
             }
-            else if ((modelType.usage & tcgc.UsageFlags.Input) === 0 && (modelType.usage & tcgc.UsageFlags.Output) === 0) {
+            else if ((modelType.usage & tcgc.UsageFlags.Input) === 0 &&
+                (modelType.usage & tcgc.UsageFlags.Output) === 0) {
                 // skip types without input and output usage
                 continue;
             }
@@ -73,7 +79,8 @@ export class TypeAdapter {
                 // we flatten these params into their underlying type
                 continue;
             }
-            else if (helpers.isHttpFileType(modelType) || (modelType.baseModel && helpers.isHttpFileType(modelType.baseModel))) {
+            else if (helpers.isHttpFileType(modelType) ||
+                (modelType.baseModel && helpers.isHttpFileType(modelType.baseModel))) {
                 // use use streaming.MultipartContent from azcore
                 continue;
             }
@@ -115,7 +122,7 @@ export class TypeAdapter {
             if (content.addlProps) {
                 const annotations = new go.ModelFieldAnnotations(false, false, true, false);
                 const addlPropsType = new go.Map(this.getWireType(content.addlProps, false, false), helpers.isTypePassedByValue(content.addlProps));
-                const addlProps = new go.ModelField('AdditionalProperties', addlPropsType, true, '', annotations);
+                const addlProps = new go.ModelField("AdditionalProperties", addlPropsType, true, "", annotations);
                 modelType.go.fields.push(addlProps);
             }
             this.getPkg().models.push(modelType.go);
@@ -131,11 +138,11 @@ export class TypeAdapter {
                 }
             }
             for (const sdkMethod of client.methods) {
-                if (sdkMethod.kind !== 'paging') {
+                if (sdkMethod.kind !== "paging") {
                     continue;
                 }
                 for (const httpResp of sdkMethod.operation.responses.values()) {
-                    if (!httpResp.type || httpResp.type.kind !== 'model') {
+                    if (!httpResp.type || httpResp.type.kind !== "model") {
                         continue;
                     }
                     if (!pagedResponses.find((each) => each.name === httpResp.type.name)) {
@@ -154,38 +161,42 @@ export class TypeAdapter {
     // returns the same instance of the converted type.
     getWireType(type, elementTypeByValue, substituteDiscriminator) {
         switch (type.kind) {
-            case 'boolean':
-            case 'bytes':
-            case 'decimal':
-            case 'decimal128':
-            case 'float':
-            case 'float32':
-            case 'float64':
-            case 'int8':
-            case 'int16':
-            case 'int32':
-            case 'int64':
-            case 'uint8':
-            case 'uint16':
-            case 'uint32':
-            case 'uint64':
-            case 'unknown':
-            case 'safeint':
-            case 'plainDate':
-            case 'plainTime':
-            case 'string':
-            case 'url':
+            case "boolean":
+            case "bytes":
+            case "decimal":
+            case "decimal128":
+            case "float":
+            case "float32":
+            case "float64":
+            case "int8":
+            case "int16":
+            case "int32":
+            case "int64":
+            case "uint8":
+            case "uint16":
+            case "uint32":
+            case "uint64":
+            case "unknown":
+            case "safeint":
+            case "plainDate":
+            case "plainTime":
+            case "string":
+            case "url":
                 return this.getBuiltInType(type);
-            case 'array': {
+            case "array": {
                 let elementType = type.valueType;
                 let nullable = false;
-                if (elementType.kind === 'nullable') {
+                if (elementType.kind === "nullable") {
                     // unwrap the nullable type
                     elementType = elementType.type;
                     nullable = true;
                 }
                 // prefer elementTypeByValue. if false, then if the array elements have been explicitly marked as nullable then prefer that, else fall back to our usual algorithm
-                const myElementTypeByValue = elementTypeByValue ? true : nullable ? false : this.codeModel.options.sliceElementsByval || helpers.isTypePassedByValue(elementType);
+                const myElementTypeByValue = elementTypeByValue
+                    ? true
+                    : nullable
+                        ? false
+                        : this.codeModel.options.sliceElementsByval || helpers.isTypePassedByValue(elementType);
                 const keyName = recursiveKeyName(`array-${myElementTypeByValue}`, elementType, substituteDiscriminator);
                 let arrayType = this.types.get(keyName);
                 if (arrayType) {
@@ -195,19 +206,19 @@ export class TypeAdapter {
                 this.types.set(keyName, arrayType);
                 return arrayType;
             }
-            case 'endpoint': {
+            case "endpoint": {
                 return this.getStringType();
             }
-            case 'enum':
+            case "enum":
                 return this.getConstantType(type);
-            case 'constant':
-            case 'enumvalue':
+            case "constant":
+            case "enumvalue":
                 return this.getLiteralValue(type);
-            case 'offsetDateTime':
+            case "offsetDateTime":
                 return this.getTimeType(type.encode, false);
-            case 'utcDateTime':
+            case "utcDateTime":
                 return this.getTimeType(type.encode, true);
-            case 'dict': {
+            case "dict": {
                 const valueTypeByValue = helpers.isTypePassedByValue(type.valueType);
                 const keyName = recursiveKeyName(`dict-${valueTypeByValue}`, type.valueType, substituteDiscriminator);
                 let mapType = this.types.get(keyName);
@@ -218,31 +229,32 @@ export class TypeAdapter {
                 this.types.set(keyName, mapType);
                 return mapType;
             }
-            case 'duration': {
+            case "duration": {
                 switch (type.wireType.kind) {
-                    case 'float':
-                    case 'float32':
-                    case 'float64':
-                    case 'int32':
-                    case 'int64':
-                    case 'string':
+                    case "float":
+                    case "float32":
+                    case "float64":
+                    case "int32":
+                    case "int64":
+                    case "string":
                         return this.getBuiltInType(type.wireType);
                     default:
-                        throw new AdapterError('UnsupportedTsp', `unsupported duration wire format kind ${type.wireType.kind}`, type.wireType.__raw?.node);
+                        throw new AdapterError("UnsupportedTsp", `unsupported duration wire format kind ${type.wireType.kind}`, type.wireType.__raw?.node);
                 }
             }
-            case 'model':
+            case "model":
                 if (helpers.isPolymorphicRoot(type) && substituteDiscriminator) {
                     return this.getInterfaceType(type);
                 }
-                else if (helpers.isHttpFileType(type) || (type.baseModel && helpers.isHttpFileType(type.baseModel))) {
+                else if (helpers.isHttpFileType(type) ||
+                    (type.baseModel && helpers.isHttpFileType(type.baseModel))) {
                     return this.getMultipartContent(false);
                 }
                 return this.getModel(type);
-            case 'nullable':
+            case "nullable":
                 return this.getWireType(type.type, elementTypeByValue, substituteDiscriminator);
             default:
-                throw new AdapterError('UnsupportedTsp', `unsupported type kind ${type.kind}`, type.__raw?.node);
+                throw new AdapterError("UnsupportedTsp", `unsupported type kind ${type.kind}`, type.__raw?.node);
         }
     }
     getTimeType(encode, utc) {
@@ -257,9 +269,9 @@ export class TypeAdapter {
     }
     // returns the Go code model type for an io.ReadSeekCloser
     getReadSeekCloser(sliceOf) {
-        let keyName = 'io-readseekcloser';
+        let keyName = "io-readseekcloser";
         if (sliceOf) {
-            keyName = 'sliceof-' + keyName;
+            keyName = "sliceof-" + keyName;
         }
         let rsc = this.types.get(keyName);
         if (!rsc) {
@@ -282,12 +294,12 @@ export class TypeAdapter {
      * @returns the go.MultipartContent instance
      */
     getMultipartContent(sliceOf, contentType) {
-        let keyName = 'streaming-multipartcontent';
+        let keyName = "streaming-multipartcontent";
         if (contentType) {
             keyName += `-${contentType}`;
         }
         if (sliceOf) {
-            keyName = 'sliceof-' + keyName;
+            keyName = "sliceof-" + keyName;
         }
         let mpc = this.types.get(keyName);
         if (!mpc) {
@@ -302,9 +314,9 @@ export class TypeAdapter {
     }
     getBuiltInType(type) {
         switch (type.kind) {
-            case 'unknown': {
+            case "unknown": {
                 if (this.codeModel.options.rawJSONAsBytes) {
-                    const anyRawJSONKey = 'any-raw-json';
+                    const anyRawJSONKey = "any-raw-json";
                     let anyRawJSON = this.types.get(anyRawJSONKey);
                     if (anyRawJSON) {
                         return anyRawJSON;
@@ -313,104 +325,104 @@ export class TypeAdapter {
                     this.types.set(anyRawJSONKey, anyRawJSON);
                     return anyRawJSON;
                 }
-                let anyType = this.types.get('any');
+                let anyType = this.types.get("any");
                 if (anyType) {
                     return anyType;
                 }
                 anyType = new go.Any();
-                this.types.set('any', anyType);
+                this.types.set("any", anyType);
                 return anyType;
             }
-            case 'boolean': {
-                const boolKey = 'boolean';
+            case "boolean": {
+                const boolKey = "boolean";
                 let primitiveBool = this.types.get(boolKey);
                 if (primitiveBool) {
                     return primitiveBool;
                 }
-                primitiveBool = new go.Scalar('bool', type.encode === 'string');
+                primitiveBool = new go.Scalar("bool", type.encode === "string");
                 this.types.set(boolKey, primitiveBool);
                 return primitiveBool;
             }
-            case 'bytes':
+            case "bytes":
                 return this.adaptBytesType(type);
-            case 'plainDate': {
-                const dateKey = 'plainDate';
+            case "plainDate": {
+                const dateKey = "plainDate";
                 let date = this.types.get(dateKey);
                 if (date) {
                     return date;
                 }
-                date = new go.Time('PlainDate', false);
+                date = new go.Time("PlainDate", false);
                 this.types.set(dateKey, date);
                 return date;
             }
-            case 'decimal':
-            case 'decimal128': {
-                const decimalKey = 'float64';
+            case "decimal":
+            case "decimal128": {
+                const decimalKey = "float64";
                 let decimalType = this.types.get(decimalKey);
                 if (decimalType) {
                     return decimalType;
                 }
-                decimalType = new go.Scalar(decimalKey, type.encode === 'string');
+                decimalType = new go.Scalar(decimalKey, type.encode === "string");
                 this.types.set(decimalKey, decimalType);
                 return decimalType;
             }
-            case 'float': // C# and Java define float as 32 bits so we're following suit
-            case 'float32': {
-                const float32Key = 'float32';
+            case "float": // C# and Java define float as 32 bits so we're following suit
+            case "float32": {
+                const float32Key = "float32";
                 let float32 = this.types.get(float32Key);
                 if (float32) {
                     return float32;
                 }
-                float32 = new go.Scalar(float32Key, type.encode === 'string');
+                float32 = new go.Scalar(float32Key, type.encode === "string");
                 this.types.set(float32Key, float32);
                 return float32;
             }
-            case 'float64': {
-                const float64Key = 'float64';
+            case "float64": {
+                const float64Key = "float64";
                 let float64 = this.types.get(float64Key);
                 if (float64) {
                     return float64;
                 }
-                float64 = new go.Scalar(float64Key, type.encode === 'string');
+                float64 = new go.Scalar(float64Key, type.encode === "string");
                 this.types.set(float64Key, float64);
                 return float64;
             }
-            case 'int8':
-            case 'int16':
-            case 'int32':
-            case 'int64':
-            case 'uint8':
-            case 'uint16':
-            case 'uint32':
-            case 'uint64': {
-                const keyName = type.encode === 'string' ? `${type.kind}-string` : type.kind;
+            case "int8":
+            case "int16":
+            case "int32":
+            case "int64":
+            case "uint8":
+            case "uint16":
+            case "uint32":
+            case "uint64": {
+                const keyName = type.encode === "string" ? `${type.kind}-string` : type.kind;
                 let intType = this.types.get(keyName);
                 if (intType) {
                     return intType;
                 }
-                intType = new go.Scalar(type.kind, type.encode === 'string');
+                intType = new go.Scalar(type.kind, type.encode === "string");
                 this.types.set(keyName, intType);
                 return intType;
             }
-            case 'safeint': {
-                const safeintkey = type.encode === 'string' ? 'int64-string' : 'int64';
+            case "safeint": {
+                const safeintkey = type.encode === "string" ? "int64-string" : "int64";
                 let int64 = this.types.get(safeintkey);
                 if (int64) {
                     return int64;
                 }
-                int64 = new go.Scalar('int64', type.encode === 'string');
+                int64 = new go.Scalar("int64", type.encode === "string");
                 this.types.set(safeintkey, int64);
                 return int64;
             }
-            case 'string':
-            case 'url': {
-                if (type.crossLanguageDefinitionId === 'Azure.Core.eTag') {
+            case "string":
+            case "url": {
+                if (type.crossLanguageDefinitionId === "Azure.Core.eTag") {
                     return this.getETagType();
                 }
                 return this.getStringType();
             }
-            case 'plainTime': {
-                const encoding = 'PlainTime';
+            case "plainTime": {
+                const encoding = "PlainTime";
                 let time = this.types.get(encoding);
                 if (time) {
                     return time;
@@ -420,20 +432,20 @@ export class TypeAdapter {
                 return time;
             }
             default:
-                throw new AdapterError('UnsupportedTsp', `unsupported type kind ${type.kind}`, type.__raw?.node);
+                throw new AdapterError("UnsupportedTsp", `unsupported type kind ${type.kind}`, type.__raw?.node);
         }
     }
     // converts an SdkEnumType to a go.ConstantType
     getConstantType(enumType) {
         let constTypeName = helpers.getEffectiveName(enumType);
-        if (enumType.access === 'internal') {
-            constTypeName = naming.getEscapedReservedName(naming.uncapitalize(constTypeName), 'Type');
+        if (enumType.access === "internal") {
+            constTypeName = naming.getEscapedReservedName(naming.uncapitalize(constTypeName), "Type");
         }
         let constType = this.types.get(constTypeName);
         if (constType) {
             return constType;
         }
-        const accessPrefix = enumType.access === 'internal' ? 'p' : 'P';
+        const accessPrefix = enumType.access === "internal" ? "p" : "P";
         constType = new go.Constant(this.getPkg(), constTypeName, getPrimitiveType(enumType.valueType), `${accessPrefix}ossible${constTypeName}Values`);
         constType.values = this.getConstantValues(constType, enumType.values);
         constType.docs.summary = enumType.summary;
@@ -442,7 +454,7 @@ export class TypeAdapter {
         return constType;
     }
     getETagType() {
-        const etagKey = 'etag';
+        const etagKey = "etag";
         let etag = this.types.get(etagKey);
         if (etag) {
             return etag;
@@ -462,7 +474,7 @@ export class TypeAdapter {
     getLiteral(type, value, extensibleEnum = true) {
         let literalKey = `literal-${type.kind}`;
         switch (type.kind) {
-            case 'constant': {
+            case "constant": {
                 // find the const value that matches the clientDefaultValue
                 const constantValue = type.values.find((v) => v.value === value);
                 if (constantValue) {
@@ -474,17 +486,17 @@ export class TypeAdapter {
                     literalKey = `${literalKey}-${type.name}`;
                 }
                 else {
-                    throw new AdapterError('UnsupportedTsp', `invalid client side default ${value} for fixed enum ${type.name}`);
+                    throw new AdapterError("UnsupportedTsp", `invalid client side default ${value} for fixed enum ${type.name}`);
                 }
                 break;
             }
-            case 'encodedBytes':
+            case "encodedBytes":
                 literalKey = `${literalKey}-${type.encoding}`;
                 break;
-            case 'scalar':
+            case "scalar":
                 literalKey = `${literalKey}-${type.type}`;
                 break;
-            case 'time':
+            case "time":
                 literalKey = `${literalKey}-${type.format}-${type.utc}`;
         }
         literalKey = `${literalKey}-${value}`;
@@ -497,7 +509,7 @@ export class TypeAdapter {
     }
     /** returns a Go string type */
     getStringType() {
-        const stringKey = 'string';
+        const stringKey = "string";
         let stringType = this.types.get(stringKey);
         if (!stringType) {
             stringType = new go.String();
@@ -507,13 +519,13 @@ export class TypeAdapter {
     }
     getInterfaceType(model) {
         if (model.name.length === 0) {
-            throw new AdapterError('InternalError', 'unnamed model');
+            throw new AdapterError("InternalError", "unnamed model");
         }
         if (!helpers.isPolymorphicRoot(model)) {
-            throw new AdapterError('InternalError', `type ${model.name} isn't a discriminator root`, model.__raw?.node);
+            throw new AdapterError("InternalError", `type ${model.name} isn't a discriminator root`, model.__raw?.node);
         }
         let ifaceName = naming.createPolymorphicInterfaceName(helpers.getEffectiveName(model));
-        if (model.access === 'internal') {
+        if (model.access === "internal") {
             ifaceName = naming.uncapitalize(ifaceName);
         }
         let iface = this.types.get(ifaceName);
@@ -523,14 +535,14 @@ export class TypeAdapter {
         // find the discriminator field
         let discriminatorField;
         for (const prop of model.properties) {
-            if (prop.kind === 'property' && prop.discriminator) {
+            if (prop.kind === "property" && prop.discriminator) {
                 // only json support discriminator type
                 discriminatorField = prop.serializationOptions.json?.name;
                 break;
             }
         }
         if (!discriminatorField) {
-            throw new AdapterError('InternalError', `failed to find discriminator field for type ${model.name}`);
+            throw new AdapterError("InternalError", `failed to find discriminator field for type ${model.name}`);
         }
         iface = new go.Interface(this.getPkg(), ifaceName, discriminatorField);
         if (model.baseModel && helpers.isPolymorphicRoot(model.baseModel)) {
@@ -542,8 +554,8 @@ export class TypeAdapter {
     // converts an SdkModelType to a go.ModelType or go.PolymorphicType if the model is polymorphic
     getModel(model) {
         let modelName = helpers.getEffectiveName(model);
-        if (model.access === 'internal') {
-            modelName = naming.getEscapedReservedName(naming.uncapitalize(modelName), 'Model');
+        if (model.access === "internal") {
+            modelName = naming.getEscapedReservedName(naming.uncapitalize(modelName), "Model");
         }
         let modelType = this.types.get(modelName);
         if (modelType) {
@@ -557,16 +569,16 @@ export class TypeAdapter {
             usage |= go.UsageFlags.Output;
         }
         let omitSerde = false;
-        const omitValue = helpers.getClientOption('omitSerdeMethods', model, this.ctx.program);
+        const omitValue = helpers.getClientOption("omitSerdeMethods", model, this.ctx.program);
         if (omitValue) {
             switch (omitValue) {
-                case 'all':
+                case "all":
                     omitSerde = true;
                     break;
                 default:
                     this.ctx.program.reportDiagnostic({
-                        code: 'InvalidClientOption',
-                        severity: 'warning',
+                        code: "InvalidClientOption",
+                        severity: "warning",
                         message: `invalid omitSerdeMethods value ${omitValue} on model ${model.name}`,
                         target: model.__raw?.node ?? tsp.NoTarget,
                     });
@@ -591,13 +603,13 @@ export class TypeAdapter {
                     parent = parent.baseModel;
                 }
                 if (!iface) {
-                    throw new AdapterError('InternalError', `failed to find discriminator interface name for type ${model.name}`);
+                    throw new AdapterError("InternalError", `failed to find discriminator interface name for type ${model.name}`);
                 }
             }
             if (model.discriminatorValue) {
                 // find the discriminator property and create the discriminator literal based on it
                 for (const prop of model.properties) {
-                    if (prop.kind === 'property' && prop.discriminator) {
+                    if (prop.kind === "property" && prop.discriminator) {
                         discriminatorLiteral = this.getDiscriminatorLiteral(prop);
                         break;
                     }
@@ -633,11 +645,11 @@ export class TypeAdapter {
     }
     getDiscriminatorLiteral(sdkProp) {
         switch (sdkProp.type.kind) {
-            case 'constant':
-            case 'enumvalue':
+            case "constant":
+            case "enumvalue":
                 return this.getLiteralValue(sdkProp.type);
             default:
-                throw new AdapterError('UnsupportedTsp', `unsupported type kind ${sdkProp.type.kind} for discriminator property ${sdkProp.name}`, sdkProp.__raw?.node);
+                throw new AdapterError("UnsupportedTsp", `unsupported type kind ${sdkProp.type.kind} for discriminator property ${sdkProp.name}`, sdkProp.__raw?.node);
         }
     }
     getModelField(prop, modelType) {
@@ -646,17 +658,20 @@ export class TypeAdapter {
         // don't have to deal with JSON patch shenanigans. only the optional fields will be pointer-to-type.
         const isMultipartFormData = (modelType.usage & tcgc.UsageFlags.MultipartFormData) !== 0;
         let fieldByValue = isMultipartFormData ? true : helpers.isTypePassedByValue(prop.type);
-        if (isMultipartFormData && prop.kind === 'property' && prop.optional) {
+        if (isMultipartFormData && prop.kind === "property" && prop.optional) {
             fieldByValue = false;
         }
         let type = this.getWireType(prop.type, isMultipartFormData, true);
-        if (prop.kind === 'property') {
+        if (prop.kind === "property") {
             if (prop.serializationOptions.multipart?.isFilePart) {
                 // for file parts, check if the tsp defines a fixed content type
                 // (e.g. HttpPart<File<"image/png">>). if so, bake it into the MultipartContent type.
                 const multipartOpts = prop.serializationOptions.multipart;
-                const fixedContentType = multipartOpts?.contentType?.type.kind === 'constant' && multipartOpts.defaultContentTypes.length === 1 ? multipartOpts.defaultContentTypes[0] : undefined;
-                type = this.getMultipartContent(prop.type.kind === 'array', fixedContentType);
+                const fixedContentType = multipartOpts?.contentType?.type.kind === "constant" &&
+                    multipartOpts.defaultContentTypes.length === 1
+                    ? multipartOpts.defaultContentTypes[0]
+                    : undefined;
+                type = this.getMultipartContent(prop.type.kind === "array", fixedContentType);
             }
             if (prop.visibility) {
                 // the field is read-only IFF the only visibility attribute present is Read.
@@ -679,7 +694,9 @@ export class TypeAdapter {
             // e.g. /typespec-go/test/tsp/HardwareSecurityModules.Management/CloudHsmCluster.tsp#L99-L105
             serializedName = prop.serializedName;
         }
-        const fieldName = prop.isExactName ? prop.name : naming.capitalize(naming.ensureNameCase(prop.name));
+        const fieldName = prop.isExactName
+            ? prop.name
+            : naming.capitalize(naming.ensureNameCase(prop.name));
         const field = new go.ModelField(fieldName, type, fieldByValue, serializedName, annotations);
         field.docs.summary = prop.summary;
         field.docs.description = prop.doc;
@@ -691,7 +708,7 @@ export class TypeAdapter {
         }
         else if (prop.clientDefaultValue) {
             if (!go.isLiteralValueType(type)) {
-                throw new AdapterError('InternalError', `unexpected client side default kind ${type.kind} for field ${field.name}`, prop.__raw?.node);
+                throw new AdapterError("InternalError", `unexpected client side default kind ${type.kind} for field ${field.name}`, prop.__raw?.node);
             }
             field.defaultValue = this.getLiteral(type, prop.clientDefaultValue, helpers.isExtensibleEnum(prop.type));
             if (!field.docs.summary && !field.docs.description) {
@@ -704,7 +721,7 @@ export class TypeAdapter {
             type: type,
             xml: prop.serializationOptions.xml,
         });
-        if (helpers.hasDecorator('@deserializeEmptyStringAsNull', prop.decorators)) {
+        if (helpers.hasDecorator("@deserializeEmptyStringAsNull", prop.decorators)) {
             field.annotations.unmarshalEmptyStringAsNil = true;
         }
         // it's possible for different models to reference the same property definition
@@ -717,8 +734,8 @@ export class TypeAdapter {
         const values = new Array();
         for (const valueType of valueTypes) {
             let valueTypeName = `${type.name}${helpers.getEffectiveName(valueType)}`;
-            if (valueType.enumType.access === 'internal') {
-                valueTypeName = naming.getEscapedReservedName(naming.uncapitalize(valueTypeName), 'Type');
+            if (valueType.enumType.access === "internal") {
+                valueTypeName = naming.getEscapedReservedName(naming.uncapitalize(valueTypeName), "Type");
             }
             if (this.constValues.has(valueTypeName)) {
                 // we have a type name collision. while tsp will prevent this
@@ -732,7 +749,7 @@ export class TypeAdapter {
                 // "ApplicationJSON".
                 // instead of being clever, report a NameCollision diagnostic so
                 // that the tsp author can define the desired names.
-                throw new AdapterError('NameCollision', `enum value ${valueType.name} was renamed to ${valueTypeName} which collides with an existing value`, valueType.__raw?.node);
+                throw new AdapterError("NameCollision", `enum value ${valueType.name} was renamed to ${valueTypeName} which collides with an existing value`, valueType.__raw?.node);
             }
             const value = new go.ConstantValue(valueTypeName, type, valueType.value);
             value.docs.summary = valueType.summary;
@@ -743,9 +760,9 @@ export class TypeAdapter {
         return values;
     }
     adaptBytesType(sdkType) {
-        let format = 'Std';
-        if (sdkType.encode === 'base64url') {
-            format = 'URL';
+        let format = "Std";
+        if (sdkType.encode === "base64url") {
+            format = "URL";
         }
         const keyName = `bytes-${format}`;
         let bytesType = this.types.get(keyName);
@@ -757,33 +774,44 @@ export class TypeAdapter {
         return bytesType;
     }
     getLiteralValue(constType) {
-        if (constType.kind === 'enumvalue') {
-            const valueName = `${helpers.getEffectiveName(constType.enumType)}${helpers.getEffectiveName(constType)}`;
-            const keyName = `literal-${valueName}`;
+        if (constType.kind === "enumvalue") {
+            const goConstType = this.getConstantType(constType.enumType);
+            // find the matching enum value
+            let goConstValue;
+            for (const value of goConstType.values) {
+                if (value.value === constType.value) {
+                    goConstValue = value;
+                    break;
+                }
+            }
+            if (!goConstValue) {
+                throw new AdapterError("InternalError", `failed to find const value for ${constType.value} in const ${goConstType.name}`, constType.__raw?.node);
+            }
+            const keyName = `literal-${goConstValue.name}`;
             let literalConst = this.types.get(keyName);
             if (literalConst) {
                 return literalConst;
             }
-            const constValue = this.constValues.get(valueName);
+            const constValue = this.constValues.get(goConstValue.name);
             if (!constValue) {
-                throw new AdapterError('InternalError', `failed to find const value for ${constType.name} in enum ${constType.enumType.name}`, constType.__raw?.node);
+                throw new AdapterError("InternalError", `failed to find const value for ${constType.name} in enum ${constType.enumType.name}`, constType.__raw?.node);
             }
             literalConst = new go.Literal(this.getConstantType(constType.enumType), constValue);
             this.types.set(keyName, literalConst);
             return literalConst;
         }
         switch (constType.valueType.kind) {
-            case 'boolean': {
+            case "boolean": {
                 const keyName = `literal-boolean-${constType.value}`;
                 let literalBool = this.types.get(keyName);
                 if (literalBool) {
                     return literalBool;
                 }
-                literalBool = new go.Literal(new go.Scalar('bool', false), constType.value);
+                literalBool = new go.Literal(new go.Scalar("bool", false), constType.value);
                 this.types.set(keyName, literalBool);
                 return literalBool;
             }
-            case 'bytes': {
+            case "bytes": {
                 const keyName = `literal-bytes-${constType.value}`;
                 let literalByteArray = this.types.get(keyName);
                 if (literalByteArray) {
@@ -793,14 +821,14 @@ export class TypeAdapter {
                 this.types.set(keyName, literalByteArray);
                 return literalByteArray;
             }
-            case 'decimal':
-            case 'decimal128': {
+            case "decimal":
+            case "decimal128": {
                 const keyName = `literal-${constType.valueType.kind}-${constType.value}`;
                 let literalDecimal = this.types.get(keyName);
                 if (literalDecimal) {
                     return literalDecimal;
                 }
-                literalDecimal = new go.Literal(new go.Scalar('float64', false), constType.value);
+                literalDecimal = new go.Literal(new go.Scalar("float64", false), constType.value);
                 this.types.set(keyName, literalDecimal);
                 return literalDecimal;
             }
@@ -817,14 +845,14 @@ export class TypeAdapter {
               this.types.set(keyName, literalTime);
               return literalTime;
             }*/
-            case 'int8':
-            case 'int16':
-            case 'int32':
-            case 'int64':
-            case 'uint8':
-            case 'uint16':
-            case 'uint32':
-            case 'uint64': {
+            case "int8":
+            case "int16":
+            case "int32":
+            case "int64":
+            case "uint8":
+            case "uint16":
+            case "uint32":
+            case "uint64": {
                 const keyName = `literal-${constType.valueType.kind}-${constType.value}`;
                 let literalInt = this.types.get(keyName);
                 if (literalInt) {
@@ -834,8 +862,8 @@ export class TypeAdapter {
                 this.types.set(keyName, literalInt);
                 return literalInt;
             }
-            case 'float32':
-            case 'float64': {
+            case "float32":
+            case "float64": {
                 const keyName = `literal-${constType.valueType.kind}-${constType.value}`;
                 let literalFloat = this.types.get(keyName);
                 if (literalFloat) {
@@ -845,8 +873,8 @@ export class TypeAdapter {
                 this.types.set(keyName, literalFloat);
                 return literalFloat;
             }
-            case 'string':
-            case 'url': {
+            case "string":
+            case "url": {
                 const keyName = `literal-string-${constType.value}`;
                 let literalString = this.types.get(keyName);
                 if (literalString) {
@@ -857,63 +885,63 @@ export class TypeAdapter {
                 return literalString;
             }
             default:
-                throw new AdapterError('UnsupportedTsp', `unsupported kind ${constType.valueType.kind} for LiteralValue`, constType.valueType.__raw?.node);
+                throw new AdapterError("UnsupportedTsp", `unsupported kind ${constType.valueType.kind} for LiteralValue`, constType.valueType.__raw?.node);
         }
         // TODO: tcgc doesn't support duration as a literal value
     }
 }
 function getPrimitiveType(type) {
     switch (type.kind) {
-        case 'boolean':
-            return 'bool';
-        case 'float32':
-        case 'float64':
-        case 'int32':
-        case 'int64':
-        case 'string':
+        case "boolean":
+            return "bool";
+        case "float32":
+        case "float64":
+        case "int32":
+        case "int64":
+        case "string":
             return type.kind;
         default:
-            throw new AdapterError('UnsupportedTsp', `unhandled tcgc.SdkBuiltInKinds: ${type.kind}`, type.__raw?.node);
+            throw new AdapterError("UnsupportedTsp", `unhandled tcgc.SdkBuiltInKinds: ${type.kind}`, type.__raw?.node);
     }
 }
 function getDateTimeEncoding(encoding) {
     switch (encoding) {
-        case 'rfc3339':
-            return 'RFC3339';
-        case 'rfc7231':
-            return 'RFC7231';
-        case 'unixTimestamp':
-            return 'Unix';
+        case "rfc3339":
+            return "RFC3339";
+        case "rfc7231":
+            return "RFC7231";
+        case "unixTimestamp":
+            return "Unix";
         default:
-            throw new AdapterError('UnsupportedTsp', `unsupported date time encoding ${encoding}`);
+            throw new AdapterError("UnsupportedTsp", `unsupported date time encoding ${encoding}`);
     }
 }
 function recursiveKeyName(root, obj, substituteDiscriminator) {
     switch (obj.kind) {
-        case 'array':
+        case "array":
             return recursiveKeyName(`${root}-array`, obj.valueType, substituteDiscriminator);
-        case 'enum':
+        case "enum":
             return `${root}-${obj.name}`;
-        case 'enumvalue':
+        case "enumvalue":
             return `${root}-${obj.enumType.name}-${obj.value}`;
-        case 'dict':
+        case "dict":
             return recursiveKeyName(`${root}-dict`, obj.valueType, substituteDiscriminator);
-        case 'plainDate':
+        case "plainDate":
             return `${root}-dateType`;
-        case 'utcDateTime':
+        case "utcDateTime":
             return `${root}-${getDateTimeEncoding(obj.encode)}`;
-        case 'duration':
+        case "duration":
             return `${root}-${obj.wireType.kind}`;
-        case 'model':
+        case "model":
             if (substituteDiscriminator) {
                 return `${root}-${naming.createPolymorphicInterfaceName(obj.name)}`;
             }
             return `${root}-${obj.name}`;
-        case 'nullable':
+        case "nullable":
             return recursiveKeyName(root, obj.type, substituteDiscriminator);
-        case 'plainTime':
-            if (obj.encode !== 'rfc3339') {
-                throw new AdapterError('UnsupportedTsp', `unsupported time encoding ${obj.encode}`, obj.__raw?.node);
+        case "plainTime":
+            if (obj.encode !== "rfc3339") {
+                throw new AdapterError("UnsupportedTsp", `unsupported time encoding ${obj.encode}`, obj.__raw?.node);
             }
             return `${root}-timeRFC3339`;
         default: