@azure-tools/typespec-go 0.17.4 → 0.17.5-dev.10

package/dist/src/codegen/core/models.js

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as go from "../../codemodel/index.js";
+import * as naming from "../../naming/index.js";
 import * as helpers from "./helpers.js";
 import { ImportManager } from "./imports.js";
 /**
@@ -333,21 +334,22 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
     const modelDefs = new Array();
     for (const model of models) {
         for (const field of model.fields) {
+            const fieldType = go.unwrapPtr(field.type);
             const descriptionMods = new Array();
             if (field.annotations.readOnly) {
                 descriptionMods.push("READ-ONLY");
             }
             else if (field.annotations.required &&
-                (field.type.kind !== "literal" || model.usage === go.UsageFlags.Output)) {
+                (fieldType.kind !== "literal" || model.usage === go.UsageFlags.Output)) {
                 descriptionMods.push("REQUIRED");
             }
-            else if (field.type.kind === "literal") {
+            else if (fieldType.kind === "literal" || go.isSlice(fieldType, "literal")) {
                 if (!field.annotations.required) {
                     descriptionMods.push("FLAG");
                 }
                 descriptionMods.push("CONSTANT");
             }
-            if (field.type.kind === "literal" && model.usage !== go.UsageFlags.Output) {
+            if ((fieldType.kind === "literal" || go.isSlice(fieldType, "literal")) && model.usage !== go.UsageFlags.Output) {
                 // add a comment with the const value for const properties that are sent over the wire
                 if (field.docs.description) {
                     field.docs.description += "\n";
@@ -355,9 +357,9 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
                 else {
                     field.docs.description = "";
                 }
-                field.docs.description += `Field has constant value ${helpers.formatLiteralValue(field.type, false)}, any specified value is ignored.`;
+                field.docs.description += `Field has constant value ${formatLiteralValue(fieldType, model.pkg, false)}, any specified value is ignored.`;
             }
-            else if (field.type.kind === "rawJSON") {
+            else if (fieldType.kind === "rawJSON") {
                 // raw JSON is emitted as []byte, so document that the field contains raw
                 // JSON and that the caller is responsible for marshaling their data structure.
                 if (field.docs.description) {
@@ -392,24 +394,26 @@ function generateModelDefs(modelImports, serdeImports, pkg, options, indent) {
             let needsDateTimeMarshalling = false;
             let byteArrayFormat = false;
             for (const field of model.fields) {
-                if (field.type.kind !== "etag") {
+                const fieldType = go.unwrapPtr(field.type);
+                if (fieldType.kind !== "etag") {
                     // azcore.ETag un/marshals on its own so no need to
                     // import azcore as we don't explicitly reference the type
-                    serdeImports.addForType(field.type);
+                    serdeImports.addForType(fieldType);
                 }
-                if (field.type.kind === "time") {
+                if (fieldType.kind === "time") {
                     needsDateTimeMarshalling = true;
                 }
-                else if (field.type.kind === "encodedBytes") {
+                else if (fieldType.kind === "encodedBytes") {
                     byteArrayFormat = true;
                 }
             }
             // due to differences in XML marshallers/unmarshallers, we use different codegen than for JSON
             const needsXMLDictionaryUnmarshalling = needsXMLDictionaryHelper(model);
             if (needsDateTimeMarshalling ||
-                model.xml?.name ||
+                model.xmlName ||
                 needsXMLArrayMarshalling(model) ||
-                byteArrayFormat) {
+                byteArrayFormat ||
+                needsXMLNestedModelMarshalling(model)) {
                 generateXMLMarshaller(modelDef, serdeImports, indent);
                 if (needsDateTimeMarshalling || needsXMLDictionaryUnmarshalling || byteArrayFormat) {
                     generateXMLUnmarshaller(modelDef, serdeImports, indent);
@@ -466,6 +470,34 @@ function needsXMLArrayMarshalling(modelType) {
     }
     return false;
 }
+/**
+ * returns true if the model contains one or more nested models
+ * where the field's serialized name is different from the model's
+ * XML name. the field's serialized name takes precedence.
+ *
+ * @param modelType the model to inspect
+ * @returns true if a custom marshaller is required
+ */
+function needsXMLNestedModelMarshalling(modelType) {
+    for (const field of modelType.fields) {
+        if (fieldNeedsXMLNestedModelMarshalling(field)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * narrows field to a Model or Ptr<Model> type that requires custom
+ * marshalling due to the field's serialized name being different from
+ * the model's XML name.
+ *
+ * @param field the field to inspect
+ * @returns a Model or Ptr<Model> that requires custom marshalling
+ */
+function fieldNeedsXMLNestedModelMarshalling(field) {
+    const fieldType = go.unwrapPtr(field.type);
+    return fieldType.kind === "model" && !!fieldType.xmlName && field.serializedName !== fieldType.xmlName;
+}
 // generates discriminator marker method
 function generateDiscriminatorMarkerMethod(type, modelDef, indent) {
     const typeName = type.rootType.name;
@@ -497,15 +529,12 @@ function generateToMultipartForm(modelDef, indent) {
     let method = `func (${receiver} ${modelDef.Model.name}) toMultipartFormData() (map[string]any, error) {\n`;
     method += `${indent.get()}objectMap := make(map[string]any)\n`;
     for (const field of modelDef.Model.fields) {
-        const fieldType = helpers.recursiveUnwrapMapSlice(field.type);
-        let star = "";
-        if (!field.byValue) {
-            star = "*";
-        }
-        if (!field.byValue) {
+        const star = helpers.deref(field.type);
+        if (field.type.kind === "ptr") {
             method += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             indent.push();
         }
+        const fieldType = helpers.recursiveUnwrapMapSlice(field.type);
         if (fieldType.kind === "model" && !fieldType.annotations.multipartFormData) {
             method += `${indent.get()}if err := populateMultipartJSON(objectMap, "${field.serializedName}", ${star}${receiver}.${field.name}); err != nil {\n`;
             method += `${indent.push().get()}return nil, err\n`;
@@ -514,7 +543,7 @@ function generateToMultipartForm(modelDef, indent) {
         else {
             method += `${indent.get()}objectMap["${field.serializedName}"] = ${star}${receiver}.${field.name}\n`;
         }
-        if (!field.byValue) {
+        if (field.type.kind === "ptr") {
             indent.pop();
             method += `${indent.get()}}\n`;
         }
@@ -571,6 +600,10 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
             addlProps = field.type;
             continue;
         }
+        // pointer-ness is captured in the code model, so dispatch on the unwrapped
+        // type and read isPtr to decide pointer-to-type emission.
+        const fieldType = go.unwrapPtr(field.type);
+        const deref = helpers.deref(field.type);
         if (field.annotations.isDiscriminator) {
             if (field.defaultValue) {
                 marshaller += `${indent.get()}objectMap["${field.serializedName}"] = ${helpers.formatLiteralValue(field.defaultValue, true)}\n`;
@@ -581,31 +614,28 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 marshaller += `${indent.get()}objectMap["${field.serializedName}"] = ${receiver}.${field.name}\n`;
             }
         }
-        else if (field.type.kind === "encodedBytes") {
+        else if (fieldType.kind === "encodedBytes") {
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             marshaller += `${indent.get()}populateByteArray(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() any {\n`;
-            marshaller += `${indent.push().get()}return runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
+            marshaller += `${indent.push().get()}return runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${fieldType.encoding}Format)\n`;
             marshaller += `${indent.pop().get()}})\n`;
             modelDef.SerDe.needsJSONPopulateByteArray = true;
         }
-        else if (go.isSlice(field.type, "encodedBytes")) {
+        else if (go.isSlice(fieldType, "encodedBytes")) {
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             marshaller += `${indent.get()}populateByteArray(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() any {\n`;
             marshaller += `${indent.push().get()}encodedValue := make([]string, len(${receiver}.${field.name}))\n`;
             marshaller += `${indent.get()}for i := 0; i < len(${receiver}.${field.name}); i++ {\n`;
-            marshaller += `${indent.push().get()}encodedValue[i] = runtime.EncodeByteArray(${receiver}.${field.name}[i], runtime.Base64${field.type.elementType.encoding}Format)\n`;
+            marshaller += `${indent.push().get()}encodedValue[i] = runtime.EncodeByteArray(${receiver}.${field.name}[i], runtime.Base64${fieldType.itemType.encoding}Format)\n`;
             marshaller += `${indent.pop().get()}}\n`;
             marshaller += `${indent.get()}return encodedValue\n`;
             marshaller += `${indent.pop().get()}})\n`;
             modelDef.SerDe.needsJSONPopulateByteArray = true;
         }
-        else if (go.isSlice(field.type, "time")) {
+        else if (go.isSlice(fieldType, "time")) {
             const source = `${receiver}.${field.name}`;
-            const elementType = field.type.elementType;
-            let elementPtr = "*";
-            if (field.type.elementTypeByValue) {
-                elementPtr = "";
-            }
+            const elementType = go.unwrapPtr(fieldType.itemType);
+            const elementPtr = helpers.deref(fieldType.itemType);
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             marshaller += `${indent.get()}aux := make([]${elementPtr}datetime.${elementType.format}, len(${source}), len(${source}))\n`;
             marshaller += `${indent.get()}for i := 0; i < len(${source}); i++ {\n`;
@@ -626,8 +656,8 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
             marshaller += `${indent.get()}populate(objectMap, "${field.serializedName}", aux)\n`;
             modelDef.SerDe.needsJSONPopulate = true;
         }
-        else if (field.type.kind === "literal") {
-            const setter = `objectMap["${field.serializedName}"] = ${helpers.formatLiteralValue(field.type, true)}`;
+        else if (fieldType.kind === "literal" || go.isSlice(fieldType, "literal")) {
+            const setter = `objectMap["${field.serializedName}"] = ${formatLiteralValue(fieldType, modelDef.Model.pkg, true)}`;
             if (!field.annotations.required) {
                 marshaller += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
                 marshaller += `${indent.push().get()}${setter}\n`;
@@ -637,7 +667,7 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 marshaller += `${indent.get()}${setter}\n`;
             }
         }
-        else if (field.type.kind === "rawJSON") {
+        else if (fieldType.kind === "rawJSON") {
             marshaller += `${indent.get()}populate(objectMap, "${field.serializedName}", json.RawMessage(${receiver}.${field.name}))\n`;
             modelDef.SerDe.needsJSONPopulate = true;
         }
@@ -648,24 +678,24 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 marshaller += `${indent.push().get()}${receiver}.${field.name} = to.Ptr(${helpers.formatLiteralValue(field.defaultValue, true)})\n`;
                 marshaller += `${indent.pop().get()}}\n`;
             }
-            if (go.isScalar(field.type, "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64") &&
-                field.type.encodeAsString) {
+            if (go.isScalar(fieldType, "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64") &&
+                fieldType.encodeAsString) {
                 imports.add("strconv");
                 marshaller += `${indent.get()}populateAsString(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() string {\n`;
-                const isSigned = field.type.type.startsWith("int");
-                let fieldExpr = `*${receiver}.${field.name}`;
-                if ((field.type.type.startsWith("uint") && field.type.type !== "uint64") ||
-                    (field.type.type.startsWith("int") && field.type.type !== "int64")) {
+                const isSigned = fieldType.type.startsWith("int");
+                let fieldExpr = `${deref}${receiver}.${field.name}`;
+                if ((fieldType.type.startsWith("uint") && fieldType.type !== "uint64") ||
+                    (fieldType.type.startsWith("int") && fieldType.type !== "int64")) {
                     fieldExpr = `${isSigned ? "int64" : "uint64"}(${fieldExpr})`;
                 }
                 marshaller += `${indent.push().get()}return strconv.${isSigned ? "FormatInt" : "FormatUint"}(${fieldExpr}, 10)\n`;
                 marshaller += `${indent.pop().get()}})\n`;
                 modelDef.SerDe.needsJSONPopulateAsString = true;
             }
-            else if (go.isScalar(field.type, "bool") && field.type.encodeAsString) {
+            else if (go.isScalar(fieldType, "bool") && fieldType.encodeAsString) {
                 imports.add("strconv");
                 marshaller += `${indent.get()}populateAsString(objectMap, "${field.serializedName}", ${receiver}.${field.name}, func() string {\n`;
-                marshaller += `${indent.push().get()}return strconv.FormatBool(*${receiver}.${field.name})\n`;
+                marshaller += `${indent.push().get()}return strconv.FormatBool(${deref}${receiver}.${field.name})\n`;
                 marshaller += `${indent.pop().get()}})\n`;
                 modelDef.SerDe.needsJSONPopulateAsString = true;
             }
@@ -673,19 +703,19 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
                 let populate;
                 // some helpers require extra args after the common ones
                 let populateArgs = "";
-                if (field.type.kind === "time") {
+                if (fieldType.kind === "time") {
                     imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-                    populate = `populateTime[datetime.${field.type.format}]`;
-                    populateArgs = `, ${field.type.utc}`;
+                    populate = `populateTime[datetime.${fieldType.format}]`;
+                    populateArgs = `, ${fieldType.utc}`;
                     modelDef.SerDe.needsJSONPopulateTime = true;
                 }
-                else if (field.type.kind === "any") {
+                else if (fieldType.kind === "any") {
                     populate = "populateAny";
                     modelDef.SerDe.needsJSONPopulateAny = true;
                 }
-                else if (field.type.kind === "sliceArray") {
+                else if (fieldType.kind === "sliceArray") {
                     populate = "populateStringArray";
-                    populateArgs = `, "${getSliceArrayDelimiter(field.type.delimiter)}"`;
+                    populateArgs = `, "${getSliceArrayDelimiter(fieldType.delimiter)}"`;
                     modelDef.SerDe.needsJSONPopulateStringArray = true;
                 }
                 else {
@@ -699,20 +729,20 @@ function generateJSONMarshallerBody(modelDef, receiver, imports, indent) {
     if (addlProps) {
         marshaller += `${indent.get()}if ${receiver}.AdditionalProperties != nil {\n`;
         marshaller += `${indent.push().get()}for key, val := range ${receiver}.AdditionalProperties {\n`;
-        if (addlProps.valueType.kind === "time" && addlProps.valueType.utc) {
+        if (go.isPtr(addlProps.itemType, "time") && addlProps.itemType.ptrType.utc) {
             // normalize utc datetimes before casting the (pointer) map value
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
             marshaller += `${indent.push().get()}if val != nil {\n`;
             marshaller += `${indent.push().get()}utcTime := val.UTC()\n`;
-            marshaller += `${indent.get()}objectMap[key] = (*datetime.${addlProps.valueType.format})(&utcTime)\n`;
+            marshaller += `${indent.get()}objectMap[key] = (*datetime.${addlProps.itemType.ptrType.format})(&utcTime)\n`;
             marshaller += `${indent.pop().get()}} else {\n`;
             marshaller += `${indent.push().get()}objectMap[key] = nil\n`;
             marshaller += `${indent.pop().get()}}\n`;
         }
         else {
             let assignment = "val";
-            if (addlProps.valueType.kind === "time") {
-                assignment = `(*${addlProps.valueType.format})(val)`;
+            if (go.isPtr(addlProps.itemType, "time")) {
+                assignment = `(*${addlProps.itemType.ptrType.format})(val)`;
             }
             marshaller += `${indent.push().get()}objectMap[key] = ${assignment}\n`;
         }
@@ -772,18 +802,15 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
     const emitAddlProps = function (addlProps) {
         // indent is at the case body level when called
         let addlPropsText = `${indent.get()}if ${receiver}.AdditionalProperties == nil {\n`;
-        let ref = "";
-        if (!addlProps.valueTypeByValue) {
-            ref = "&";
-        }
+        const ref = addlProps.itemType.kind === "ptr" ? "&" : "";
         addlPropsText += `${indent.push().get()}${receiver}.AdditionalProperties = ${go.getTypeDeclaration(addlProps, modelDef.Model.pkg)}{}\n`;
         addlPropsText += `${indent.pop().get()}}\n`;
         addlPropsText += `${indent.get()}if val != nil {\n`;
-        let auxType = go.getTypeDeclaration(addlProps.valueType, modelDef.Model.pkg);
+        let auxType = go.getTypeDeclaration(go.unwrapPtr(addlProps.itemType), modelDef.Model.pkg);
         let assignment = `${ref}aux`;
-        if (addlProps.valueType.kind === "time") {
+        if (go.isPtr(addlProps.itemType, "time")) {
             imports.add("time");
-            auxType = addlProps.valueType.format;
+            auxType = addlProps.itemType.ptrType.format;
             assignment = `(*time.Time)(${assignment})`;
         }
         addlPropsText += `${indent.push().get()}var aux ${auxType}\n`;
@@ -804,30 +831,30 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 addlProps = field.type;
                 continue;
             }
+            // dispatch on the unwrapped type; pointer-ness is captured in the code model.
+            const fieldType = go.unwrapPtr(field.type);
             unmarshalBody += `${indent.get()}case "${field.serializedName}":\n`;
             indent.push(); // case body level
-            if (hasDiscriminatorInterface(field.type)) {
+            if (hasDiscriminatorInterface(fieldType)) {
                 unmarshalBody += generateDiscriminatorUnmarshaller(modelDef.Model, field, receiver, indent);
                 needsErrCheck = true;
             }
-            else if (field.type.kind === "sliceArray") {
-                unmarshalBody += `${indent.get()}err = unpopulateStringArray(val, "${field.name}", &${receiver}.${field.name}, "${getSliceArrayDelimiter(field.type.delimiter)}")\n`;
+            else if (fieldType.kind === "sliceArray") {
+                unmarshalBody += `${indent.get()}err = unpopulateStringArray(val, "${field.name}", &${receiver}.${field.name}, "${getSliceArrayDelimiter(fieldType.delimiter)}")\n`;
                 modelDef.SerDe.needsJSONUnpopulateStringArray = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === "time") {
-                unmarshalBody += `${indent.get()}err = unpopulateTime[datetime.${field.type.format}](val, "${field.name}", &${receiver}.${field.name})\n`;
+            else if (fieldType.kind === "time") {
+                unmarshalBody += `${indent.get()}err = unpopulateTime[datetime.${fieldType.format}](val, "${field.name}", &${receiver}.${field.name})\n`;
                 modelDef.SerDe.needsJSONUnpopulateTime = true;
                 needsErrCheck = true;
             }
-            else if (go.isSlice(field.type, "time")) {
+            else if (go.isSlice(fieldType, "time")) {
                 imports.add("time");
                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-                let elementPtr = "*";
-                if (field.type.elementTypeByValue) {
-                    elementPtr = "";
-                }
-                unmarshalBody += `${indent.get()}var aux []${elementPtr}datetime.${field.type.elementType.format}\n`;
+                const elementType = go.unwrapPtr(fieldType.itemType);
+                const elementPtr = helpers.deref(fieldType.itemType);
+                unmarshalBody += `${indent.get()}var aux []${elementPtr}datetime.${elementType.format}\n`;
                 unmarshalBody += `${indent.get()}err = unpopulate(val, "${field.name}", &aux)\n`;
                 unmarshalBody += `${indent.get()}for _, au := range aux {\n`;
                 unmarshalBody += `${indent.push().get()}${receiver}.${field.name} = append(${receiver}.${field.name}, (${elementPtr}time.Time)(au))\n`;
@@ -835,14 +862,14 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 modelDef.SerDe.needsJSONUnpopulate = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === "encodedBytes") {
+            else if (fieldType.kind === "encodedBytes") {
                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
                 unmarshalBody += `${indent.get()}if val != nil && string(val) != "null" {\n`;
-                unmarshalBody += `${indent.push().get()}err = runtime.DecodeByteArray(string(val), &${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
+                unmarshalBody += `${indent.push().get()}err = runtime.DecodeByteArray(string(val), &${receiver}.${field.name}, runtime.Base64${fieldType.encoding}Format)\n`;
                 unmarshalBody += `${indent.pop().get()}}\n`;
                 needsErrCheck = true;
             }
-            else if (go.isSlice(field.type, "encodedBytes")) {
+            else if (go.isSlice(fieldType, "encodedBytes")) {
                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
                 unmarshalBody += `${indent.get()}var encodedValue []string\n`;
                 unmarshalBody += `${indent.get()}err = unpopulate(val, "${field.name}", &encodedValue)\n`;
@@ -850,19 +877,19 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 indent.push();
                 unmarshalBody += `${indent.get()}${receiver}.${field.name} = make([][]byte, len(encodedValue))\n`;
                 unmarshalBody += `${indent.get()}for i := 0; i < len(encodedValue) && err == nil; i++ {\n`;
-                unmarshalBody += `${indent.push().get()}err = runtime.DecodeByteArray(encodedValue[i], &${receiver}.${field.name}[i], runtime.Base64${field.type.elementType.encoding}Format)\n`;
+                unmarshalBody += `${indent.push().get()}err = runtime.DecodeByteArray(encodedValue[i], &${receiver}.${field.name}[i], runtime.Base64${fieldType.itemType.encoding}Format)\n`;
                 unmarshalBody += `${indent.pop().get()}}\n`;
                 indent.pop();
                 unmarshalBody += `${indent.get()}}\n`;
                 modelDef.SerDe.needsJSONUnpopulate = true;
                 needsErrCheck = true;
             }
-            else if (field.type.kind === "rawJSON") {
+            else if (fieldType.kind === "rawJSON") {
                 unmarshalBody += `${indent.get()}if string(val) != "null" {\n`;
                 unmarshalBody += `${indent.push().get()}${receiver}.${field.name} = val\n`;
                 unmarshalBody += `${indent.pop().get()}}\n`;
             }
-            else if (go.isScalar(field.type, "bool") && field.type.encodeAsString) {
+            else if (go.isScalar(fieldType, "bool") && fieldType.encodeAsString) {
                 imports.add("strconv");
                 imports.add("strings");
                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
@@ -877,13 +904,13 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
                 modelDef.SerDe.needsJSONUnpopulateFromString = true;
                 needsErrCheck = true;
             }
-            else if (go.isScalar(field.type, "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64") &&
-                field.type.encodeAsString) {
-                const scalarType = field.type.type;
+            else if (go.isScalar(fieldType, "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64") &&
+                fieldType.encodeAsString) {
+                const scalarType = fieldType.type;
                 imports.add("strconv");
                 imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/to");
                 unmarshalBody += `${indent.get()}err = unpopulateFromString(val, "${field.name}", func(encodedValue string) error {\n`;
-                unmarshalBody += `${indent.push().get()}v, parseErr := strconv.${field.type.type.startsWith("int") ? "ParseInt" : "ParseUint"}(encodedValue, 10, 0)\n`;
+                unmarshalBody += `${indent.push().get()}v, parseErr := strconv.${fieldType.type.startsWith("int") ? "ParseInt" : "ParseUint"}(encodedValue, 10, 0)\n`;
                 unmarshalBody += `${indent.get()}${helpers.buildIfBlock(indent, {
                     condition: "parseErr == nil",
                     body: (indent) => {
@@ -902,7 +929,7 @@ function generateJSONUnmarshallerBody(modelDef, receiver, options, imports, inde
             }
             else {
                 const unpopulateField = `err = unpopulate(val, "${field.name}", &${receiver}.${field.name})\n`;
-                if (field.type.kind === "string" && field.annotations.unmarshalEmptyStringAsNil) {
+                if (fieldType.kind === "string" && field.annotations.unmarshalEmptyStringAsNil) {
                     unmarshalBody += `${indent.get()}${helpers.buildIfBlock(indent, {
                         condition: `string(val) != \`""\``,
                         body: (indent) => `${indent.get()}${unpopulateField}`,
@@ -975,9 +1002,8 @@ function hasDiscriminatorInterface(item) {
         case "interface":
             return true;
         case "map":
-            return hasDiscriminatorInterface(item.valueType);
         case "slice":
-            return hasDiscriminatorInterface(item.elementType);
+            return hasDiscriminatorInterface(item.itemType);
         default:
             return false;
     }
@@ -990,10 +1016,10 @@ function generateDiscriminatorUnmarshaller(modelType, field, receiver, indent) {
         return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.name}(val)\n`;
     }
     else if (go.isSlice(field.type, "interface")) {
-        return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.elementType.name}Array(val)\n`;
+        return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.itemType.name}Array(val)\n`;
     }
     else if (go.isMap(field.type, "interface")) {
-        return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.valueType.name}Map(val)\n`;
+        return `${indent.get()}${receiver}.${propertyName}, err = unmarshal${field.type.itemType.name}Map(val)\n`;
     }
     // nested case (e.g. [][]InterfaceType, map[string]map[string]InterfaceType etc)
     // first, unmarshal the raw data
@@ -1025,13 +1051,13 @@ function generateDiscriminatorUnmarshaller(modelType, field, receiver, indent) {
 function recursiveGetDiscriminatorTypeName(modelType, item, raw) {
     // when raw is true, stop recursing at the level before the leaf schema
     if (item.kind === "slice") {
-        if (!raw || item.elementType.kind !== "interface") {
-            return `[]${recursiveGetDiscriminatorTypeName(modelType, item.elementType, raw)}`;
+        if (!raw || item.itemType.kind !== "interface") {
+            return `[]${recursiveGetDiscriminatorTypeName(modelType, item.itemType, raw)}`;
         }
     }
     else if (item.kind === "map") {
-        if (!raw || item.valueType.kind !== "interface") {
-            return `map[string]${recursiveGetDiscriminatorTypeName(modelType, item.valueType, raw)}`;
+        if (!raw || item.itemType.kind !== "interface") {
+            return `map[string]${recursiveGetDiscriminatorTypeName(modelType, item.itemType, raw)}`;
         }
     }
     if (raw) {
@@ -1056,7 +1082,7 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
     let interfaceName = "";
     let targetType = "";
     if (item.kind === "slice") {
-        if (item.elementType.kind !== "interface") {
+        if (item.itemType.kind !== "interface") {
             if (nesting > 1) {
                 // at nestling level 1, the destination var was already created in generateDiscriminatorUnmarshaller()
                 text += `${indent.get()}${dest} = make(${recursiveGetDiscriminatorTypeName(modelType, item, false)}, len(${rawSrc}))\n`;
@@ -1065,17 +1091,17 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
             rawSrc = `${rawSrc}[i${nesting}]`; // source becomes each element in the source slice
             dest = `${dest}[i${nesting}]`; // update destination to each element in the destination slice
             indent.push();
-            text += recursivePopulateDiscriminator(modelType, item.elementType, receiver, rawSrc, dest, indent, nesting + 1);
+            text += recursivePopulateDiscriminator(modelType, item.itemType, receiver, rawSrc, dest, indent, nesting + 1);
             indent.pop();
             text += `${indent.get()}}\n`;
             return text;
         }
         // we're at leaf node - 1, so get the interface from the element's type
-        interfaceName = go.getTypeDeclaration(item.elementType, modelType.pkg);
+        interfaceName = go.getTypeDeclaration(item.itemType, modelType.pkg);
         targetType = "Array";
     }
     else if (item.kind === "map") {
-        if (item.valueType.kind !== "interface") {
+        if (item.itemType.kind !== "interface") {
             if (nesting > 1) {
                 // at nestling level 1, the destination var was already created in generateDiscriminatorUnmarshaller()
                 text += `${indent.get()}${dest} = ${recursiveGetDiscriminatorTypeName(modelType, item, false)}{}\n`;
@@ -1084,13 +1110,13 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
             rawSrc = `v${nesting}`; // source becomes the current value in the source map
             dest = `${dest}[k${nesting}]`; // update destination to the destination map's value for the current key
             indent.push();
-            text += recursivePopulateDiscriminator(modelType, item.valueType, receiver, rawSrc, dest, indent, nesting + 1);
+            text += recursivePopulateDiscriminator(modelType, item.itemType, receiver, rawSrc, dest, indent, nesting + 1);
             indent.pop();
             text += `${indent.get()}}\n`;
             return text;
         }
         // we're at leaf node - 1, so get the interface from the element's type
-        interfaceName = go.getTypeDeclaration(item.valueType, modelType.pkg);
+        interfaceName = go.getTypeDeclaration(item.itemType, modelType.pkg);
         targetType = "Map";
     }
     text += `${indent.get()}${dest}, err = unmarshal${interfaceName}${targetType}(${rawSrc})\n`;
@@ -1099,6 +1125,11 @@ function recursivePopulateDiscriminator(modelType, item, receiver, rawSrc, dest,
     text += `${indent.pop().get()}}\n`;
     return text;
 }
+/** returns the alias type name to use when aliasing a model type */
+function getXMLNestedModelAliasTypeName(type) {
+    const fieldType = go.unwrapPtr(type);
+    return naming.uncapitalize(fieldType.name);
+}
 /**
  * generates an implementation of MarshalXML for the provided type.
  * the method impl is added to modelDef.SerDe.methods.
@@ -1111,28 +1142,43 @@ function generateXMLMarshaller(modelDef, imports, indent) {
     const receiver = modelDef.receiverName();
     const desc = `MarshalXML implements the xml.Marshaller interface for type ${modelDef.Model.name}.`;
     let text = `func (${receiver} ${modelDef.Model.name}) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {\n`;
-    if (modelDef.Model.xml?.name) {
-        text += `${indent.get()}start.Name.Local = "${modelDef.Model.xml.name}"\n`;
+    if (modelDef.Model.xmlName) {
+        text += `${indent.get()}start.Name.Local = "${modelDef.Model.xmlName}"\n`;
+    }
+    // declare the type aliases for custom marshalling first
+    // as the containing type's alias type depends on them
+    for (const field of modelDef.Model.fields) {
+        if (fieldNeedsXMLNestedModelMarshalling(field)) {
+            const fieldType = go.unwrapPtr(field.type);
+            text += `${indent.get()}type ${getXMLNestedModelAliasTypeName(field.type)} ${fieldType.name}\n`;
+        }
     }
     text += generateAliasType(modelDef.Model, receiver, true, imports, indent);
     for (const field of modelDef.Model.fields) {
-        if (field.type.kind === "slice") {
+        const fieldType = go.unwrapPtr(field.type);
+        if (fieldType.kind === "slice") {
             text += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             text += `${indent.push().get()}aux.${field.name} = &${receiver}.${field.name}\n`;
             text += `${indent.pop().get()}}\n`;
         }
-        else if (go.isAdditionalProperties(field) || field.type.kind === "map") {
+        else if (go.isAdditionalProperties(field) || fieldType.kind === "map") {
             text += `${indent.get()}aux.${field.name} = (additionalProperties)(${receiver}.${field.name})\n`;
         }
-        else if (field.type.kind === "encodedBytes") {
+        else if (fieldType.kind === "encodedBytes") {
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             text += `${indent.get()}if ${receiver}.${field.name} != nil {\n`;
             indent.push();
-            text += `${indent.get()}encoded${field.name} := runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format)\n`;
+            text += `${indent.get()}encoded${field.name} := runtime.EncodeByteArray(${receiver}.${field.name}, runtime.Base64${fieldType.encoding}Format)\n`;
             text += `${indent.get()}aux.${field.name} = &encoded${field.name}\n`;
             indent.pop();
             text += `${indent.get()}}\n`;
         }
+        else if (fieldNeedsXMLNestedModelMarshalling(field)) {
+            text += `${indent.get()}${helpers.buildIfBlock(indent, {
+                condition: `${receiver}.${field.name} != nil`,
+                body: (indent) => `${indent.get()}aux.${field.name} = (*${getXMLNestedModelAliasTypeName(field.type)})(${receiver}.${field.name})\n`,
+            })}\n`;
+        }
     }
     text += `${indent.get()}return enc.EncodeElement(aux, start)\n`;
     text += "}\n\n";
@@ -1155,19 +1201,20 @@ function generateXMLUnmarshaller(modelDef, imports, indent) {
     text += `${indent.push().get()}return err\n`;
     text += `${indent.pop().get()}}\n`;
     for (const field of modelDef.Model.fields) {
-        if (field.type.kind === "time") {
+        const fieldType = go.unwrapPtr(field.type);
+        if (fieldType.kind === "time") {
             text += `${indent.get()}if aux.${field.name} != nil && !(*time.Time)(aux.${field.name}).IsZero() {\n`;
             text += `${indent.push().get()}${receiver}.${field.name} = (*time.Time)(aux.${field.name})\n`;
             text += `${indent.pop().get()}}\n`;
         }
-        else if (go.isAdditionalProperties(field) || field.type.kind === "map") {
+        else if (go.isAdditionalProperties(field) || fieldType.kind === "map") {
             text += `${indent.get()}${receiver}.${field.name} = (map[string]*string)(aux.${field.name})\n`;
         }
-        else if (field.type.kind === "encodedBytes") {
+        else if (fieldType.kind === "encodedBytes") {
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime");
             text += `${indent.get()}if aux.${field.name} != nil {\n`;
             indent.push();
-            text += `${indent.get()}if err := runtime.DecodeByteArray(*aux.${field.name}, &${receiver}.${field.name}, runtime.Base64${field.type.encoding}Format); err != nil {\n`;
+            text += `${indent.get()}if err := runtime.DecodeByteArray(*aux.${field.name}, &${receiver}.${field.name}, runtime.Base64${fieldType.encoding}Format); err != nil {\n`;
             text += `${indent.push().get()}return err\n`;
             text += `${indent.pop().get()}}\n`;
             indent.pop();
@@ -1191,20 +1238,24 @@ function generateAliasType(modelType, receiver, forMarshal, imports, indent) {
     text += `${indent.get()}aux := &struct {\n`;
     text += `${indent.push().get()}*alias\n`;
     for (const field of modelType.fields) {
-        const sn = getXMLSerialization(field);
-        if (field.type.kind === "time") {
+        const fieldType = go.unwrapPtr(field.type);
+        const sn = getXMLSerialization(field, modelType.pkg);
+        if (fieldType.kind === "time") {
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-            text += `${indent.get()}${field.name} *datetime.${field.type.format} \`xml:"${sn}"\`\n`;
+            text += `${indent.get()}${field.name} *datetime.${fieldType.format} \`xml:"${sn}"\`\n`;
         }
-        else if (go.isAdditionalProperties(field) || field.type.kind === "map") {
+        else if (go.isAdditionalProperties(field) || fieldType.kind === "map") {
             text += `${indent.get()}${field.name} additionalProperties \`xml:"${sn}"\`\n`;
         }
-        else if (field.type.kind === "slice") {
-            text += `${indent.get()}${field.name} *${go.getTypeDeclaration(field.type, modelType.pkg)} \`xml:"${sn}"\`\n`;
+        else if (fieldType.kind === "slice") {
+            text += `${indent.get()}${field.name} *${go.getTypeDeclaration(fieldType, modelType.pkg)} \`xml:"${sn}"\`\n`;
         }
-        else if (field.type.kind === "encodedBytes") {
+        else if (fieldType.kind === "encodedBytes") {
             text += `${indent.get()}${field.name} *string \`xml:"${sn}"\`\n`;
         }
+        else if (fieldNeedsXMLNestedModelMarshalling(field)) {
+            text += `${indent.get()}${field.name} *${getXMLNestedModelAliasTypeName(field.type)} \`xml:"${field.serializedName}"\`\n`;
+        }
     }
     text += `${indent.pop().get()}}{\n`;
     let rec = receiver;
@@ -1215,11 +1266,12 @@ function generateAliasType(modelType, receiver, forMarshal, imports, indent) {
     if (forMarshal) {
         // emit code to initialize time fields
         for (const field of modelType.fields) {
-            if (field.type.kind !== "time") {
+            const fieldType = go.unwrapPtr(field.type);
+            if (fieldType.kind !== "time") {
                 continue;
             }
             imports.add("github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/datetime");
-            text += `${indent.get()}${field.name}: (*datetime.${field.type.format})(${receiver}.${field.name}),\n`;
+            text += `${indent.get()}${field.name}: (*datetime.${fieldType.format})(${receiver}.${field.name}),\n`;
         }
     }
     text += `${indent.pop().get()}}\n`;
@@ -1296,23 +1348,24 @@ class ModelDef {
                 text += helpers.formatDocComment(field.docs);
             }
             let typeName = go.getTypeDeclaration(field.type, this.Model.pkg);
-            if (field.type.kind === "literal") {
-                // for constants we use the underlying type name
-                typeName = go.getLiteralTypeDeclaration(field.type.type);
+            const fieldType = go.unwrapPtr(field.type);
+            if (fieldType.kind === "literal") {
+                // for constants we use the underlying type name; getTypeDeclaration above emits the pointer.
+                typeName = `${helpers.deref(field.type)}${go.getLiteralTypeDeclaration(fieldType.type)}`;
             }
             let serialization = field.serializedName;
             if (this.Format === "JSON") {
                 serialization += ",omitempty";
             }
             else if (this.Format === "XML") {
-                serialization = getXMLSerialization(field);
+                serialization = getXMLSerialization(field, this.Model.pkg);
             }
             let tag = "";
             // only emit tags for XML; JSON uses custom marshallers/unmarshallers
             if (this.Format === "XML" && !go.isAdditionalProperties(field)) {
                 tag = ` \`xml:"${serialization}"\``;
             }
-            text += `${indent.get()}${field.name} ${helpers.star(field.byValue)}${typeName}${tag}\n`;
+            text += `${indent.get()}${field.name} ${typeName}${tag}\n`;
             first = false;
         }
         text += "}\n\n";
@@ -1330,28 +1383,17 @@ class ModelDef {
  * @param field the field for which to construct the tag's contents
  * @returns the contents for the XML tag
  */
-function getXMLSerialization(field) {
+function getXMLSerialization(field, pkg) {
     let serialization = field.serializedName;
-    // default to using the serialization name
-    if (field.xml?.name) {
-        // xml can specify its own name, prefer that if available
-        serialization = field.xml.name;
-    }
-    else if (field.xml?.text) {
-        // type has the x-ms-text attribute applied so it should be character data, not a node (https://github.com/Azure/autorest/tree/main/docs/extensions#x-ms-text)
-        // see https://pkg.go.dev/encoding/xml#Unmarshal for what ,chardata actually means
-        serialization = ",chardata";
+    switch (field.xmlKind) {
+        case "attribute":
+            serialization += ",attr";
+            return serialization;
+        case "text":
+            serialization = ",chardata";
+            return serialization;
     }
-    if (field.xml?.attribute) {
-        // value comes from an xml attribute
-        serialization += ",attr";
-    }
-    else if (field.type.kind === "slice") {
-        // start with the serialized name of the element, preferring xml name if available
-        let inner = field.serializedName;
-        if (field.xml?.name) {
-            inner = field.xml.name;
-        }
+    if (field.type.kind === "slice") {
         // arrays can be wrapped or unwrapped.  here's a wrapped example
         // note how the array of apple objects is "wrapped" in GoodApples
         // <AppleBarrel>
@@ -1370,15 +1412,23 @@ function getXMLSerialization(field) {
         //     <title>Overview</title>
         //   </slide>
         // </slideshow>
-        // arrays in the response type are handled slightly different as we
-        // unmarshal directly into them so no need to add the unwrapping.
-        if (field.xml?.wraps) {
-            serialization += `>${field.xml.wraps}`;
-        }
-        else {
-            serialization = inner;
+        // for unwrapped lists we use the serialized name on the field
+        if (field.xmlKind !== "unwrappedList") {
+            // start with the serialized name of the element, preferring xml name if available
+            const unwrappedPtrType = go.unwrapPtr(field.type.itemType);
+            const inner = field.type.xmlName ? field.type.xmlName : go.hasXMLName(unwrappedPtrType) ?? go.getTypeDeclaration(unwrappedPtrType, pkg);
+            serialization += `>${inner}`;
         }
     }
     return serialization;
 }
+/** expanded version of helpers.formatLiteralValue than handles slices */
+function formatLiteralValue(type, pkg, withCast) {
+    switch (type.kind) {
+        case "literal":
+            return helpers.formatLiteralValue(type, withCast);
+        case "slice":
+            return `[]${go.getTypeDeclaration(type.itemType.type, pkg)}{${helpers.formatLiteralValue(type.itemType, withCast)}}`;
+    }
+}
 //# sourceMappingURL=models.js.map