@azure-tools/typespec-rust 0.34.0 → 0.36.0

package/dist/src/tcgcadapter/adapter.js

@@ -2,7 +2,7 @@
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
-// cspell: ignore addl responseheader subclients lropaging
+// cspell: ignore addl requiredness responseheader subclients lropaging
 import * as tsp from '@typespec/compiler';
 import * as helpers from './helpers.js';
 import * as naming from './naming.js';
@@ -10,6 +10,7 @@ import * as utils from '../utils/utils.js';
 import * as tcgc from '@azure-tools/typespec-client-generator-core';
 import * as rust from '../codemodel/index.js';
 import { FinalStateValue } from "@azure-tools/typespec-azure-core";
+import { NoTarget } from "@typespec/compiler";
 /**
  * AdapterError is thrown when the emitter fails to convert part of the tcgc code
  * model to the emitter code model. this could be due to the emitter not supporting
@@ -69,8 +70,8 @@ export class Adapter {
         this.crate = new rust.Crate(this.options['crate-name'], this.options['crate-version'], serviceType);
     }
     /** performs all the steps to convert tcgc to a crate */
-    tcgcToCrate() {
-        this.adaptTypes();
+    tcgcToCrate(context) {
+        this.adaptTypes(context);
         this.adaptClients();
         // marker models don't require serde so exclude them from the check
         if (this.crate.enums.length > 0 || this.crate.models.some(e => e.kind === 'model')) {
@@ -96,11 +97,17 @@ export class Adapter {
         };
     }
     /** converts all tcgc types to their Rust type equivalent */
-    adaptTypes() {
-        var _a;
+    adaptTypes(context) {
         for (const sdkUnion of this.ctx.sdkPackage.unions.filter(u => u.kind === 'union')) {
             if (!sdkUnion.discriminatedOptions) {
-                throw new AdapterError('UnsupportedTsp', 'non-discriminated unions are not supported', (_a = sdkUnion.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                // When https://github.com/microsoft/typespec/issues/9749 is fixed, we can return to throwing an exception here.
+                context.program.reportDiagnostic({
+                    code: 'UnsupportedTsp',
+                    severity: 'warning',
+                    message: `Non-discriminated unions ('${sdkUnion.name}') are not supported. No type will be generated.`,
+                    target: NoTarget,
+                });
+                continue;
             }
             const rustUnion = this.getDiscriminatedUnion(sdkUnion);
             this.crate.unions.push(rustUnion);
@@ -486,7 +493,7 @@ export class Adapter {
      * @returns a Rust model field
      */
     getModelField(modelFlags, property, modelVisibility, stack) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         const fieldNeedsBoxing = function (fieldType) {
             if (fieldType.kind === 'model' && stack.includes(fieldType)) {
                 // if the field's type is a model and it's in the type stack then
@@ -555,6 +562,34 @@ export class Adapter {
         else if (property.kind === 'property' && property.discriminator) {
             modelField.flags |= rust.ModelFieldFlags.Discriminator;
         }
+        // check for any client options on the field
+        const clientOptions = property.decorators.filter((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@clientOption');
+        for (const clientOption of clientOptions) {
+            const optionName = clientOption.arguments['name'];
+            const optionValue = clientOption.arguments['value'];
+            switch (optionName) {
+                case 'deserialize_with':
+                    if (modelField.customizations.find((each) => each.kind === 'deserializeWith')) {
+                        // ignore any duplicates and warn about it
+                        this.ctx.program.reportDiagnostic({
+                            code: 'DuplicateClientOption',
+                            severity: 'warning',
+                            message: `duplicate client option ${optionName} on model field ${property.name} will be ignored`,
+                            target: (_c = (_b = property.__raw) === null || _b === void 0 ? void 0 : _b.node) !== null && _c !== void 0 ? _c : tsp.NoTarget,
+                        });
+                        continue;
+                    }
+                    modelField.customizations.push(new rust.DeserializeWith(optionValue));
+                    break;
+                default:
+                    this.ctx.program.reportDiagnostic({
+                        code: 'InvalidClientOption',
+                        severity: 'warning',
+                        message: `invalid client option ${optionName} on model field ${property.name}`,
+                        target: (_e = (_d = property.__raw) === null || _d === void 0 ? void 0 : _d.node) !== null && _e !== void 0 ? _e : tsp.NoTarget,
+                    });
+            }
+        }
         return modelField;
     }
     /**
@@ -652,19 +687,11 @@ export class Adapter {
             case 'plainDate':
             case 'plainTime':
             case 'string':
-            case 'url': {
+            case 'url':
                 if (type.kind === 'string' && type.crossLanguageDefinitionId === 'Azure.Core.eTag') {
-                    const etagKey = 'Etag';
-                    let etagType = this.types.get(etagKey);
-                    if (etagType) {
-                        return etagType;
-                    }
-                    etagType = new rust.Etag(this.crate);
-                    this.types.set(etagKey, etagType);
-                    return etagType;
+                    return this.getEtag();
                 }
                 return this.getStringType();
-            }
             case 'nullable':
                 if (type.type.kind === 'model' && type.type.isGeneratedName) {
                     // if the nullable type's target type is a synthesized
@@ -737,6 +764,17 @@ export class Adapter {
         this.types.set(keyName, encodedBytesType);
         return encodedBytesType;
     }
+    /** returns a Etag type */
+    getEtag() {
+        const etagKey = 'Etag';
+        let etagType = this.types.get(etagKey);
+        if (etagType) {
+            return etagType;
+        }
+        etagType = new rust.Etag(this.crate);
+        this.types.set(etagKey, etagType);
+        return etagType;
+    }
     /** returns a HashMap<String, type> */
     getHashMap(type) {
         const keyName = recursiveKeyName('hashmap', type);
@@ -924,10 +962,7 @@ export class Adapter {
     /** converts all tcgc clients and their methods into Rust clients/methods */
     adaptClients() {
         for (const client of this.ctx.sdkPackage.clients) {
-            // start with instantiable clients and recursively work down
-            if (client.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
-                this.recursiveAdaptClient(client);
-            }
+            this.recursiveAdaptClient(client);
         }
     }
     /**
@@ -981,16 +1016,22 @@ export class Adapter {
         rustClient.docs = this.adaptDocs(client.summary, client.doc);
         rustClient.parent = parent;
         rustClient.fields.push(new rust.StructField('pipeline', 'pubCrate', new rust.ExternalType(this.crate, 'Pipeline', 'azure_core::http')));
-        // anything other than public means non-instantiable client
-        if (client.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
+        // InitializedByFlags.CustomizeCode means the client is instantiable
+        // but the constructor is to be omitted (i.e. hand-written).
+        if (client.clientInitialization.initializedBy === tcgc.InitializedByFlags.CustomizeCode || client.clientInitialization.initializedBy & tcgc.InitializedByFlags.Individually) {
             const clientOptionsStruct = new rust.Struct(`${rustClient.name}Options`, 'pub');
             const clientOptionsField = new rust.StructField('client_options', 'pub', new rust.ExternalType(this.crate, 'ClientOptions', 'azure_core::http'));
             clientOptionsField.docs.summary = 'Allows customization of the client.';
             clientOptionsField.defaultValue = 'ClientOptions::default()';
             clientOptionsStruct.fields.push(clientOptionsField);
             rustClient.constructable = new rust.ClientConstruction(new rust.ClientOptions(clientOptionsStruct));
-            rustClient.constructable.suppressed = this.options['omit-constructors'];
             clientOptionsStruct.docs.summary = `Options used when creating a ${this.asDocLink(rustClient.name, rustClient.name)}`;
+            if (this.options['omit-constructors']) {
+                rustClient.constructable.suppressed = 'yes';
+            }
+            else if (client.clientInitialization.initializedBy === tcgc.InitializedByFlags.CustomizeCode) {
+                rustClient.constructable.suppressed = 'ctor';
+            }
             // NOTE: per tcgc convention, if there is no param of kind credential
             // it means that the client doesn't require any kind of authentication.
             // HOWEVER, if there *is* a credential param, then the client *does not*
@@ -1108,6 +1149,11 @@ export class Adapter {
                         break;
                     }
                     case 'method': {
+                        // https://github.com/Azure/typespec-rust/issues/849
+                        // Azure doesn't use optional (with no explicit default value) API versions anyway.
+                        if (param.isApiVersionParam && param.optional && !param.clientDefaultValue) {
+                            param.optional = false;
+                        }
                         const clientParam = this.adaptClientParameter(param, rustClient.constructable);
                         rustClient.fields.push(new rust.StructField(clientParam.name, 'pubCrate', clientParam.type));
                         ctorParams.push(clientParam);
@@ -1401,7 +1447,7 @@ export class Adapter {
                 adaptedParam = this.adaptMethodSpreadParameter(param, this.adaptPayloadFormat(opParam.defaultContentType), opParam.type);
             }
             else {
-                adaptedParam = this.adaptMethodParameter(opParam);
+                adaptedParam = this.adaptMethodParameter(opParam, param);
             }
             switch (adaptedParam.kind) {
                 case 'headerScalar':
@@ -1688,7 +1734,8 @@ export class Adapter {
                 responseHeader = new rust.ResponseHeaderHashMap(utils.snakeCaseName(header.name), lowerCasedHeader);
             }
             else {
-                responseHeader = new rust.ResponseHeaderScalar(utils.snakeCaseName(header.name), utils.fixETagName(lowerCasedHeader), this.typeToWireType(this.getType(header.type)));
+                const headerType = lowerCasedHeader.match(/^etag$/) ? this.getEtag() : this.typeToWireType(this.getType(header.type));
+                responseHeader = new rust.ResponseHeaderScalar(utils.snakeCaseName(header.name), utils.fixETagName(lowerCasedHeader), headerType);
             }
             responseHeader.docs = this.adaptDocs(header.summary, header.doc);
             responseHeadersMap.set(header, responseHeader);
@@ -1735,14 +1782,6 @@ export class Adapter {
                     return utils.capitalize(type.kind);
             }
         };
-        const throwOnUnitType = function (type) {
-            if (type.kind === 'unit') {
-                // this is to filter out unit from ResponseTypes.
-                // methods that return unit should have been skipped by our caller
-                // so we should never hit this (if we do, we have a bug elsewhere).
-                throw new AdapterError('InternalError', `unexpected trait impl kind ${type.kind}`);
-            }
-        };
         // response header traits are only ever for marker types and payloads
         let implFor;
         switch (method.returns.type.kind) {
@@ -1751,12 +1790,23 @@ export class Adapter {
                 implFor = method.returns.type.type;
                 break;
             case 'response':
-                throwOnUnitType(method.returns.type.content);
-                implFor = method.returns.type;
+                switch (method.returns.type.content.kind) {
+                    case 'marker':
+                    case 'model':
+                        implFor = method.returns.type;
+                        break;
+                    default:
+                        throw new AdapterError('InternalError', `unexpected trait impl content kind ${method.returns.type.content.kind}`);
+                }
                 break;
             case 'asyncResponse':
-                throwOnUnitType(method.returns.type.type);
-                implFor = method.returns.type;
+                switch (method.returns.type.type.kind) {
+                    case 'marker':
+                        implFor = method.returns.type;
+                        break;
+                    default:
+                        throw new AdapterError('InternalError', `unexpected trait impl type kind ${method.returns.type.type.kind}`);
+                }
                 break;
         }
         const traitName = `${recursiveTypeName(implFor.kind === 'asyncResponse' ? implFor.type : implFor.content)}Headers`;
@@ -1882,12 +1932,17 @@ export class Adapter {
         return paramsForReinjection;
     }
     /**
-     * converts a tcgc operation parameter into a Rust method parameter
+     * converts a tcgc operation parameter into a Rust method parameter.
+     * note that when methodParam is present, we must use all applicable
+     * values from methodParam as the source of truth. e.g. when overriding
+     * a method to make an optional param required, the requiredness will
+     * be reflected in the method param, _not_ the operation param.
      *
-     * @param param the tcgc operation parameter to convert
+     * @param opParam the tcgc operation parameter to convert
+     * @param methodParam the tcgc method parameter associated with opParam
      * @returns a Rust method parameter
      */
-    adaptMethodParameter(param) {
+    adaptMethodParameter(opParam, methodParam) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         /**
          * used to create keys for this.clientMethodParams
@@ -1899,10 +1954,10 @@ export class Adapter {
             // in different places across methods (path/query)
             return `${param.name}-${param.kind}`;
         };
-        const paramLoc = param.onClient ? 'client' : 'method';
+        const paramLoc = opParam.onClient ? 'client' : 'method';
         // if this is a client method param, check if we've already adapted it
         if (paramLoc === 'client') {
-            const clientMethodParam = this.clientMethodParams.get(getClientParamsKey(param));
+            const clientMethodParam = this.clientMethodParams.get(getClientParamsKey(opParam));
             if (clientMethodParam) {
                 return clientMethodParam;
             }
@@ -1918,40 +1973,41 @@ export class Adapter {
             }
             return param.name;
         };
-        const paramName = naming.getEscapedReservedName(utils.snakeCaseName(getCorrespondingClientParamName(param)), 'param', reservedParams);
-        let paramType = this.getType(param.type);
+        const paramName = naming.getEscapedReservedName(utils.snakeCaseName(getCorrespondingClientParamName(opParam)), 'param', reservedParams);
+        const paramOptional = methodParam ? methodParam.optional : opParam.optional;
+        let paramType = this.getType(methodParam ? methodParam.type : opParam.type);
         // for required header/path/query method string params, we might emit them as borrowed types
-        if (!param.optional && !param.onClient && (param.kind === 'header' || param.kind === 'path' || param.kind === 'query')) {
-            const borrowedType = this.canBorrowMethodParam(paramType, param.kind);
+        if (!paramOptional && paramLoc !== 'client' && (opParam.kind === 'header' || opParam.kind === 'path' || opParam.kind === 'query')) {
+            const borrowedType = this.canBorrowMethodParam(paramType, opParam.kind);
             if (borrowedType) {
                 paramType = borrowedType;
             }
         }
         let adaptedParam;
-        switch (param.kind) {
+        switch (opParam.kind) {
             case 'body': {
                 let requestType;
-                if (param.type.kind === 'bytes' && param.type.encode === 'bytes') {
+                if (opParam.type.kind === 'bytes' && opParam.type.encode === 'bytes') {
                     // bytes encoding indicates a streaming binary request
                     requestType = new rust.Bytes(this.crate);
                 }
                 else {
-                    requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptPayloadFormat(param.defaultContentType));
+                    requestType = new rust.Payload(this.typeToWireType(paramType), this.adaptPayloadFormat(opParam.defaultContentType));
                 }
-                const requestFormatType = this.adaptPayloadFormatType(param.defaultContentType);
-                adaptedParam = new rust.BodyParameter(paramName, paramLoc, param.optional, new rust.RequestContent(this.crate, requestType, requestFormatType));
+                const requestFormatType = this.adaptPayloadFormatType(opParam.defaultContentType);
+                adaptedParam = new rust.BodyParameter(paramName, paramLoc, paramOptional, new rust.RequestContent(this.crate, requestType, requestFormatType));
                 break;
             }
             case 'cookie':
                 // TODO: https://github.com/Azure/typespec-rust/issues/192
-                throw new AdapterError('UnsupportedTsp', 'cookie parameters are not supported', (_a = param.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                throw new AdapterError('UnsupportedTsp', 'cookie parameters are not supported', (_a = opParam.__raw) === null || _a === void 0 ? void 0 : _a.node);
             case 'header':
-                if (param.collectionFormat) {
+                if (opParam.collectionFormat) {
                     if (paramType.kind !== 'Vec' && !isRefSlice(paramType)) {
-                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for HeaderCollectionParameter`, (_b = param.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for HeaderCollectionParameter`, (_b = opParam.__raw) === null || _b === void 0 ? void 0 : _b.node);
                     }
                     let format;
-                    switch (param.collectionFormat) {
+                    switch (opParam.collectionFormat) {
                         case 'csv':
                         case 'simple':
                             format = 'csv';
@@ -1959,18 +2015,18 @@ export class Adapter {
                         case 'pipes':
                         case 'ssv':
                         case 'tsv':
-                            format = param.collectionFormat;
+                            format = opParam.collectionFormat;
                             break;
                         default:
-                            throw new AdapterError('InternalError', `unexpected format ${param.collectionFormat} for HeaderCollectionParameter`, (_c = param.__raw) === null || _c === void 0 ? void 0 : _c.node);
+                            throw new AdapterError('InternalError', `unexpected format ${opParam.collectionFormat} for HeaderCollectionParameter`, (_c = opParam.__raw) === null || _c === void 0 ? void 0 : _c.node);
                     }
-                    adaptedParam = new rust.HeaderCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, format);
+                    adaptedParam = new rust.HeaderCollectionParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, format);
                 }
-                else if (param.serializedName === 'x-ms-meta') {
+                else if (opParam.serializedName === 'x-ms-meta') {
                     if (paramType.kind !== 'hashmap' && !isRefHashMap(paramType)) {
-                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for header ${param.serializedName}`, (_d = param.__raw) === null || _d === void 0 ? void 0 : _d.node);
+                        throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for header ${opParam.serializedName}`, (_d = opParam.__raw) === null || _d === void 0 ? void 0 : _d.node);
                     }
-                    adaptedParam = new rust.HeaderHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
+                    adaptedParam = new rust.HeaderHashMapParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType);
                 }
                 else {
                     paramType = this.typeToWireType(paramType);
@@ -1981,28 +2037,28 @@ export class Adapter {
                         case 'slice':
                         case 'str':
                         case 'Vec':
-                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar header ${param.serializedName}`, (_e = param.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar header ${opParam.serializedName}`, (_e = opParam.__raw) === null || _e === void 0 ? void 0 : _e.node);
                     }
-                    adaptedParam = new rust.HeaderScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType);
-                    adaptedParam.isApiVersion = param.isApiVersionParam;
+                    adaptedParam = new rust.HeaderScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType);
+                    adaptedParam.isApiVersion = opParam.isApiVersionParam;
                 }
                 break;
             case 'path':
                 {
                     paramType = this.typeToWireType(paramType);
                     let style = 'simple';
-                    const tspStyleString = param.style;
+                    const tspStyleString = opParam.style;
                     if (!['simple', 'path', 'label', 'matrix'].includes(tspStyleString)) {
-                        throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${param.serializedName}`, (_f = param.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                        throw new AdapterError('InternalError', `unsupported style ${tspStyleString} for parameter ${opParam.serializedName}`, (_f = opParam.__raw) === null || _f === void 0 ? void 0 : _f.node);
                     }
                     else {
                         style = tspStyleString;
                     }
                     if (isRefSlice(paramType)) {
-                        adaptedParam = new rust.PathCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
+                        adaptedParam = new rust.PathCollectionParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, opParam.allowReserved, style, opParam.explode);
                     }
                     else if (paramType.kind === 'hashmap' || isRefHashMap(paramType)) {
-                        adaptedParam = new rust.PathHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style, param.explode);
+                        adaptedParam = new rust.PathHashMapParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, opParam.allowReserved, style, opParam.explode);
                     }
                     else {
                         switch (paramType.kind) {
@@ -2011,25 +2067,25 @@ export class Adapter {
                             case 'slice':
                             case 'str':
                             case 'Vec':
-                                throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar path ${param.serializedName}`, (_g = param.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                                throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar path ${opParam.serializedName}`, (_g = opParam.__raw) === null || _g === void 0 ? void 0 : _g.node);
                         }
-                        adaptedParam = new rust.PathScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, param.allowReserved, style);
+                        adaptedParam = new rust.PathScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, opParam.allowReserved, style);
                     }
                 }
                 break;
             case 'query':
                 paramType = this.typeToWireType(paramType);
                 if (paramType.kind === 'Vec' || isRefSlice(paramType)) {
-                    let format = param.explode ? 'multi' : 'csv';
-                    if (param.collectionFormat) {
-                        format = param.collectionFormat === 'simple' ? 'csv' : (param.collectionFormat === 'form' ? 'multi' : param.collectionFormat);
+                    let format = opParam.explode ? 'multi' : 'csv';
+                    if (opParam.collectionFormat) {
+                        format = opParam.collectionFormat === 'simple' ? 'csv' : (opParam.collectionFormat === 'form' ? 'multi' : opParam.collectionFormat);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryCollectionParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, format);
+                    adaptedParam = new rust.QueryCollectionParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, true, format);
                 }
                 else if (paramType.kind === 'hashmap' || isRefHashMap(paramType)) {
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryHashMapParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true, param.explode);
+                    adaptedParam = new rust.QueryHashMapParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, true, opParam.explode);
                 }
                 else {
                     switch (paramType.kind) {
@@ -2037,17 +2093,17 @@ export class Adapter {
                         case 'model':
                         case 'slice':
                         case 'str':
-                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${param.serializedName}`, (_h = param.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${opParam.serializedName}`, (_h = opParam.__raw) === null || _h === void 0 ? void 0 : _h.node);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
-                    adaptedParam = new rust.QueryScalarParameter(paramName, param.serializedName, paramLoc, param.optional, paramType, true);
-                    adaptedParam.isApiVersion = param.isApiVersionParam;
+                    adaptedParam = new rust.QueryScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, true);
+                    adaptedParam.isApiVersion = opParam.isApiVersionParam;
                 }
                 break;
         }
-        adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
+        adaptedParam.docs = this.adaptDocs(methodParam ? methodParam.summary : opParam.summary, methodParam ? methodParam.doc : opParam.doc);
         if (paramLoc === 'client') {
-            this.clientMethodParams.set(getClientParamsKey(param), adaptedParam);
+            this.clientMethodParams.set(getClientParamsKey(opParam), adaptedParam);
         }
         return adaptedParam;
     }