Use adapted type when adapting a literal enum value

Port of Azure/autorest.go#1997 (commit 11f88629). The adapted type
contains the proper name and correctly handles internal types, fixing
adapting Access.internal operations that return a polymorphic type.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

.chronus/changes/typespec-go-fix-internal-polymorphic-enum-literal-2026-06-22-10-45-00.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@azure-tools/typespec-go"
+---
+
+Fixed adapting `Access.internal` operations that return a polymorphic type.

packages/typespec-go/src/tcgcadapter/types.ts

@@ -913,13 +913,28 @@ export class TypeAdapter {
 
   private getLiteralValue(constType: tcgc.SdkConstantType | tcgc.SdkEnumValueType): go.Literal {
     if (constType.kind === "enumvalue") {
-      const valueName = `${helpers.getEffectiveName(constType.enumType)}${helpers.getEffectiveName(constType)}`;
-      const keyName = `literal-${valueName}`;
+      const goConstType = this.getConstantType(constType.enumType);
+      // find the matching enum value
+      let goConstValue: go.ConstantValue | undefined;
+      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 <go.Literal>literalConst;
       }
-      const constValue = this.constValues.get(valueName);
+      const constValue = this.constValues.get(goConstValue.name);
       if (!constValue) {
         throw new AdapterError(
           "InternalError",

packages/typespec-go/test/tsp/Regressions/main.tsp

@@ -247,3 +247,30 @@ op payloadWithExplicitContentType(
   @body
   thing: SomeModel,
 ): void;
+
+union InboundCallerIdentityType {
+  SystemAssigned: "SystemAssigned",
+  UserAssigned: "UserAssigned",
+  string,
+}
+
+@discriminator("type")
+model InboundCallerIdentity {
+  type: InboundCallerIdentityType;
+}
+
+model SystemAssignedInboundCallerIdentity extends InboundCallerIdentity {
+  type: InboundCallerIdentityType.SystemAssigned;
+}
+
+model UserAssignedInboundCallerIdentity extends InboundCallerIdentity {
+  type: InboundCallerIdentityType.UserAssigned;
+  userAssignedIdentity: string;
+}
+
+/**
+ * gets a polymorphic type when the operation is internal (makes the dependent type graph internal)
+ */
+@access(Access.internal)
+@route("/get-caller-identity")
+op getCallerIdentity(): InboundCallerIdentity;