@azure-tools/typespec-java 0.27.2 → 0.27.4

package/dist/src/code-model-builder.js

@@ -1,8 +1,8 @@
 import { AnySchema, ApiVersion, ArraySchema, BinaryResponse, BinarySchema, BooleanSchema, ByteArraySchema, ChoiceValue, DateSchema, DateTimeSchema, DictionarySchema, Discriminator, GroupProperty, GroupSchema, HttpHeader, HttpParameter, ImplementationLocation, KeySecurityScheme, Language, Metadata, NumberSchema, OAuth2SecurityScheme, ObjectSchema, OperationGroup, Parameter, ParameterLocation, Property, Relations, Response, SchemaResponse, SchemaType, Security, SerializationStyle, StringSchema, TimeSchema, UnixTimeSchema, UriSchema, VirtualParameter, } from "@autorest/codemodel";
 import { KnownMediaType } from "@azure-tools/codegen";
-import { createSdkContext, getAllModels, getWireName, isApiVersion, isSdkBuiltInKind, isSdkIntKind, } from "@azure-tools/typespec-client-generator-core";
-import { getDoc, getEffectiveModelType, getNamespaceFullName, getOverloadedOperation, getSummary, isArrayModelType, isRecordModelType, listServices, } from "@typespec/compiler";
-import { Visibility, getAuthentication, getHeaderFieldName, getPathParamName, getQueryParamName, isCookieParam, isHeader, isPathParam, isQueryParam, } from "@typespec/http";
+import { createSdkContext, getAllModels, getHttpOperationParameter, isSdkBuiltInKind, isSdkIntKind, } from "@azure-tools/typespec-client-generator-core";
+import { NoTarget, getDoc, getNamespaceFullName, getOverloadedOperation, getSummary, isArrayModelType, isRecordModelType, listServices, } from "@typespec/compiler";
+import { Visibility, getAuthentication, } from "@typespec/http";
 import { getSegment } from "@typespec/rest";
 import { getAddedOnVersions } from "@typespec/versioning";
 import { fail } from "assert";
@@ -17,10 +17,11 @@ import { OrSchema } from "./common/schemas/relationship.js";
 import { DurationSchema } from "./common/schemas/time.js";
 import { SchemaContext } from "./common/schemas/usage.js";
 import { createPollOperationDetailsSchema, getFileDetailsSchema } from "./external-schemas.js";
+import { LIB_NAME, createDiagnostic, reportDiagnostic } from "./lib.js";
 import { ClientContext } from "./models.js";
-import { CONTENT_TYPE_KEY, ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, cloneOperationParameter, getServiceVersion, isKnownContentType, isLroNewPollingStrategy, isPayloadProperty, operationIsJsonMergePatch, operationIsMultipart, operationIsMultipleContentTypes, } from "./operation-utils.js";
-import { ProcessingCache, getAccess, getDurationFormat, getNonNullSdkType, getUnionDescription, getUsage, isStable, modelIs, pushDistinct, } from "./type-utils.js";
-import { getNamespace, logError, logWarning, pascalCase, removeClientSuffix, stringArrayContainsIgnoreCase, trace, } from "./utils.js";
+import { CONTENT_TYPE_KEY, ORIGIN_API_VERSION, SPECIAL_HEADER_NAMES, cloneOperationParameter, getServiceVersion, isKnownContentType, isLroNewPollingStrategy, operationIsJsonMergePatch, operationIsMultipart, operationIsMultipleContentTypes, } from "./operation-utils.js";
+import { ProcessingCache, getAccess, getDurationFormat, getNonNullSdkType, getPropertySerializedName, getUnionDescription, getUsage, modelIs, pushDistinct, } from "./type-utils.js";
+import { DiagnosticError, getNamespace, isStableApiVersion, pascalCase, removeClientSuffix, stringArrayContainsIgnoreCase, trace, } from "./utils.js";
 const { isEqual } = pkg;
 export class CodeModelBuilder {
     constructor(program1, context) {
@@ -35,7 +36,10 @@ export class CodeModelBuilder {
         }
         const service = listServices(this.program)[0];
         if (!service) {
-            this.logWarning("TypeSpec for HTTP client should define a service.");
+            reportDiagnostic(this.program, {
+                code: "no-service",
+                target: NoTarget,
+            });
         }
         this.serviceNamespace = (_a = service === null || service === void 0 ? void 0 : service.type) !== null && _a !== void 0 ? _a : this.program.getGlobalNamespaceType();
         this.namespace = getNamespaceFullName(this.serviceNamespace) || "Client";
@@ -69,7 +73,8 @@ export class CodeModelBuilder {
         if (this.program.hasError()) {
             return this.codeModel;
         }
-        this.sdkContext = await createSdkContext(this.emitterContext, "@azure-tools/typespec-java", {
+        this.sdkContext = await createSdkContext(this.emitterContext, LIB_NAME, {
+            additionalDecorators: ["Azure\\.ClientGenerator\\.Core\\.@override"],
             versioning: { previewStringRegex: /$/ },
         }); // include all versions and do the filter by ourselves
         // java namespace
@@ -92,7 +97,7 @@ export class CodeModelBuilder {
         // TODO: it is not very likely, but different client could have different auth
         const auth = getAuthentication(this.program, this.serviceNamespace);
         if (auth) {
-            this.processAuth(auth);
+            this.processAuth(auth, this.serviceNamespace);
         }
         if (this.sdkContext.arm) {
             // ARM
@@ -141,7 +146,7 @@ export class CodeModelBuilder {
         });
         return hostParameters;
     }
-    processAuth(auth) {
+    processAuth(auth, serviceNamespace) {
         const securitySchemes = [];
         for (const option of auth.options) {
             for (const scheme of option.schemes) {
@@ -157,7 +162,11 @@ export class CodeModelBuilder {
                             }
                             else {
                                 // there is no TokenCredential in clientcore, hence use Bearer Authentication directly
-                                this.logWarning(`OAuth2 auth scheme is generated as KeyCredential.`);
+                                reportDiagnostic(this.program, {
+                                    code: "auth-scheme-not-supported",
+                                    messageId: "oauth2Unbranded",
+                                    target: serviceNamespace,
+                                });
                                 const keyScheme = new KeySecurityScheme({
                                     name: "authorization",
                                 });
@@ -175,7 +184,11 @@ export class CodeModelBuilder {
                                 securitySchemes.push(keyScheme);
                             }
                             else {
-                                this.logWarning(`ApiKey auth is currently only supported for ApiKeyLocation.header.`);
+                                reportDiagnostic(this.program, {
+                                    code: "auth-scheme-not-supported",
+                                    messageId: "apiKeyLocation",
+                                    target: serviceNamespace,
+                                });
                             }
                         }
                         break;
@@ -187,7 +200,12 @@ export class CodeModelBuilder {
                                 schemeOrApiKeyPrefix = pascalCase(schemeOrApiKeyPrefix);
                                 if (this.isBranded()) {
                                     // Azure would not allow BasicAuth or BearerAuth
-                                    this.logWarning(`HTTP auth with ${scheme.scheme} scheme is not supported for Azure.`);
+                                    reportDiagnostic(this.program, {
+                                        code: "auth-scheme-not-supported",
+                                        messageId: "basicAuthBranded",
+                                        format: { scheme: scheme.scheme },
+                                        target: serviceNamespace,
+                                    });
                                     continue;
                                 }
                             }
@@ -358,7 +376,11 @@ export class CodeModelBuilder {
             else {
                 this.apiVersion = versions.find((it) => it === this.sdkContext.apiVersion);
                 if (!this.apiVersion) {
-                    this.logError("Unrecognized api-version: " + this.sdkContext.apiVersion);
+                    reportDiagnostic(this.program, {
+                        code: "invalid-api-version",
+                        format: { apiVersion: this.sdkContext.apiVersion },
+                        target: NoTarget,
+                    });
                 }
             }
             codeModelClient.apiVersions = [];
@@ -371,7 +393,8 @@ export class CodeModelBuilder {
         // client initialization
         let baseUri = "{endpoint}";
         let hostParameters = [];
-        client.initialization.properties.forEach((initializationProperty) => {
+        client.clientInitialization.parameters.forEach((initializationProperty) => {
+            var _a;
             if (initializationProperty.kind === "endpoint") {
                 let sdkPathParameters = [];
                 if (initializationProperty.type.kind === "union") {
@@ -385,7 +408,10 @@ export class CodeModelBuilder {
                         }
                     }
                     else if (initializationProperty.type.variantTypes.length > 2) {
-                        this.logError("Multiple server URL defined for one client is not supported yet.");
+                        reportDiagnostic(this.program, {
+                            code: "multiple-server-not-supported",
+                            target: (_a = initializationProperty.type.__raw) !== null && _a !== void 0 ? _a : NoTarget,
+                        });
                     }
                 }
                 else if (initializationProperty.type.kind === "endpoint") {
@@ -518,7 +544,7 @@ export class CodeModelBuilder {
         }
         return versions
             .slice(0, versions.indexOf(pinnedApiVersion) + 1)
-            .filter((version) => !excludePreview || !isStable(pinnedApiVersion) || isStable(version));
+            .filter((version) => !excludePreview || !isStableApiVersion(pinnedApiVersion) || isStableApiVersion(version));
     }
     needToSkipProcessingOperation(operation, clientContext) {
         // don't generate protocol and convenience method for overloaded operations
@@ -557,7 +583,7 @@ export class CodeModelBuilder {
         }
     }
     processOperation(sdkMethod, clientContext, groupName) {
-        var _a;
+        var _a, _b, _c, _d;
         const operationName = sdkMethod.name;
         const httpOperation = sdkMethod.operation;
         const operationId = groupName ? `${groupName}_${operationName}` : `${operationName}`;
@@ -576,36 +602,51 @@ export class CodeModelBuilder {
         const convenienceApiName = this.getConvenienceApiName(sdkMethod);
         let generateConvenienceApi = sdkMethod.generateConvenient;
         let generateProtocolApi = sdkMethod.generateProtocol;
-        let apiComment = undefined;
+        let diagnostic = undefined;
         if (generateConvenienceApi) {
             // check if the convenience API need to be disabled for some special cases
             if (operationIsMultipart(httpOperation)) {
                 // do not generate protocol method for multipart/form-data, as it be very hard for user to prepare the request body as BinaryData
                 generateProtocolApi = false;
-                apiComment = `Protocol API requires serialization of parts with content-disposition and data, as operation '${operationName}' is 'multipart/form-data'`;
-                this.logWarning(apiComment);
+                diagnostic = createDiagnostic({
+                    code: "protocol-api-not-generated",
+                    messageId: "multipartFormData",
+                    format: { operationName: operationName },
+                    target: (_b = sdkMethod.__raw) !== null && _b !== void 0 ? _b : NoTarget,
+                });
+                this.program.reportDiagnostic(diagnostic);
             }
             else if (operationIsMultipleContentTypes(httpOperation)) {
                 // and multiple content types
                 // issue link: https://github.com/Azure/autorest.java/issues/1958#issuecomment-1562558219
                 generateConvenienceApi = false;
-                apiComment = `Convenience API is not generated, as operation '${operationName}' is multiple content-type`;
-                this.logWarning(apiComment);
+                diagnostic = createDiagnostic({
+                    code: "convenience-api-not-generated",
+                    messageId: "multipleContentType",
+                    format: { operationName: operationName },
+                    target: (_c = sdkMethod.__raw) !== null && _c !== void 0 ? _c : NoTarget,
+                });
+                this.program.reportDiagnostic(diagnostic);
             }
             else if (operationIsJsonMergePatch(httpOperation) &&
                 this.options["stream-style-serialization"] === false) {
                 // do not generate convenient method for json merge patch operation if stream-style-serialization is not enabled
                 generateConvenienceApi = false;
-                apiComment = `Convenience API is not generated, as operation '${operationName}' is 'application/merge-patch+json' and stream-style-serialization is not enabled`;
-                this.logWarning(apiComment);
+                diagnostic = createDiagnostic({
+                    code: "convenience-api-not-generated",
+                    messageId: "jsonMergePatch",
+                    format: { operationName: operationName },
+                    target: (_d = sdkMethod.__raw) !== null && _d !== void 0 ? _d : NoTarget,
+                });
+                this.program.reportDiagnostic(diagnostic);
             }
         }
         if (generateConvenienceApi && convenienceApiName) {
             codeModelOperation.convenienceApi = new ConvenienceApi(convenienceApiName);
         }
-        if (apiComment) {
+        if (diagnostic) {
             codeModelOperation.language.java = new Language();
-            codeModelOperation.language.java.comment = apiComment;
+            codeModelOperation.language.java.comment = diagnostic.message;
         }
         // check for generating protocol api or not
         codeModelOperation.generateProtocolApi = generateProtocolApi && !codeModelOperation.internalApi;
@@ -622,8 +663,7 @@ export class CodeModelBuilder {
         clientContext.hostParameters.forEach((it) => codeModelOperation.addParameter(it));
         // path/query/header parameters
         for (const param of httpOperation.parameters) {
-            // TODO, switch to TCGC param.kind=="cookie"
-            if (param.__raw && isCookieParam(this.program, param.__raw)) {
+            if (param.kind === "cookie") {
                 // ignore cookie parameter
                 continue;
             }
@@ -645,12 +685,12 @@ export class CodeModelBuilder {
             this.processParameter(codeModelOperation, param, clientContext);
         }
         // body
+        let bodyParameterFlattened = false;
         if (httpOperation.bodyParam && httpOperation.__raw && httpOperation.bodyParam.type.__raw) {
-            this.processParameterBody(codeModelOperation, httpOperation.__raw, httpOperation, httpOperation.bodyParam);
+            bodyParameterFlattened = this.processParameterBody(codeModelOperation, sdkMethod, httpOperation.bodyParam);
         }
-        // group ETag header parameters, if exists
-        if (this.options["group-etag-headers"]) {
-            this.processEtagHeaderParameters(codeModelOperation, sdkMethod.operation);
+        if (generateConvenienceApi) {
+            this.processParameterGrouping(codeModelOperation, sdkMethod, bodyParameterFlattened);
         }
         // lro metadata
         let lroMetadata = new LongRunningMetadata(false);
@@ -674,10 +714,6 @@ export class CodeModelBuilder {
     }
     processRouteForPaged(op, responses, sdkMethod) {
         var _a, _b;
-        if (!this.isBranded()) {
-            // TODO: currently unbranded does not support paged operation
-            return;
-        }
         if (sdkMethod.kind === "paging" || sdkMethod.kind === "lropaging") {
             for (const response of responses) {
                 const bodyType = response.type;
@@ -720,7 +756,6 @@ export class CodeModelBuilder {
         }
     }
     processLroMetadata(op, sdkMethod) {
-        var _a;
         const trackConvenienceApi = Boolean(op.convenienceApi);
         const lroMetadata = sdkMethod.lroMetadata;
         if (lroMetadata && lroMetadata.pollingStep) {
@@ -764,20 +799,9 @@ export class CodeModelBuilder {
                 if (useNewPollStrategy &&
                     lroMetadata.finalStep &&
                     lroMetadata.finalStep.kind === "pollingSuccessProperty" &&
-                    lroMetadata.finalResponse.resultPath) {
-                    const finalResultPropertyClientName = lroMetadata.finalResponse.resultPath;
-                    // find serializedName for lro result
-                    if (finalResultPropertyClientName) {
-                        (_a = lroMetadata.finalResponse.envelopeResult.properties) === null || _a === void 0 ? void 0 : _a.forEach((p) => {
-                            var _a;
-                            // TODO: "p.__raw?.name" should be "p.name", after TCGC fix https://github.com/Azure/typespec-azure/issues/2072
-                            if (p.kind === "property" &&
-                                p.serializedName &&
-                                ((_a = p.__raw) === null || _a === void 0 ? void 0 : _a.name) === finalResultPropertyClientName) {
-                                finalResultPropertySerializedName = p.serializedName;
-                            }
-                        });
-                    }
+                    lroMetadata.finalResponse.resultSegments &&
+                    lroMetadata.finalResponse.resultSegments[0].kind === "property") {
+                    finalResultPropertySerializedName = getPropertySerializedName(lroMetadata.finalResponse.resultSegments[0]);
                 }
             }
             // track usage
@@ -811,8 +835,8 @@ export class CodeModelBuilder {
         }
     }
     processParameter(op, param, clientContext) {
-        var _a, _b;
-        if (clientContext.apiVersions && isApiVersion(this.sdkContext, param)) {
+        var _a, _b, _c;
+        if (clientContext.apiVersions && param.isApiVersionParam && param.kind !== "cookie") {
             // pre-condition for "isApiVersion": the client supports ApiVersions
             if (this.isArm()) {
                 // Currently we assume ARM tsp only have one client and one api-version.
@@ -825,7 +849,7 @@ export class CodeModelBuilder {
                 op.addParameter(this._armApiVersionParameter);
             }
             else {
-                const parameter = param.kind === "query" ? this.apiVersionParameter : this.apiVersionParameterInPath;
+                const parameter = this.getApiVersionParameter(param);
                 op.addParameter(parameter);
                 clientContext.addGlobalParameter(parameter);
             }
@@ -908,19 +932,19 @@ export class CodeModelBuilder {
                             break;
                         default:
                             if (format) {
-                                this.logWarning(`Unrecognized header parameter format: '${format}'.`);
+                                reportDiagnostic(this.program, {
+                                    code: "header-parameter-format-not-supported",
+                                    format: { format: format },
+                                    target: (_b = param.__raw) !== null && _b !== void 0 ? _b : NoTarget,
+                                });
                             }
                             break;
                     }
                 }
             }
-            // TODO: use param.onClient after TCGC fix
-            const parameterOnClient = !isApiVersion(this.sdkContext, param) &&
-                param.correspondingMethodParams &&
-                param.correspondingMethodParams.length > 0 &&
-                param.correspondingMethodParams[0].onClient;
+            const parameterOnClient = param.onClient;
             const nullable = param.type.kind === "nullable";
-            const parameter = new Parameter(param.name, (_b = param.doc) !== null && _b !== void 0 ? _b : "", schema, {
+            const parameter = new Parameter(param.name, (_c = param.doc) !== null && _c !== void 0 ? _c : "", schema, {
                 summary: param.summary,
                 implementation: parameterOnClient
                     ? ImplementationLocation.Client
@@ -952,6 +976,182 @@ export class CodeModelBuilder {
             }
         }
     }
+    processParameterGrouping(op, sdkMethod, bodyParameterFlattened) {
+        const httpOperation = sdkMethod.operation;
+        const methodSignatureOverridden = sdkMethod.decorators.some((it) => it.name === "Azure.ClientGenerator.Core.@override");
+        if (methodSignatureOverridden) {
+            // limit the effect of "SdkServiceMethod"
+            // only process it and its parameters, when the "@override" is defined on the operation
+            this.processSdkMethodOverride(op, sdkMethod);
+        }
+        else if (bodyParameterFlattened) {
+            // only do this, if no explicit method override via "@override"
+            this.checkGroupingAfterBodyParameterFlatten(op);
+        }
+        // group ETag header parameters, if exists
+        if (this.options["group-etag-headers"]) {
+            // TODO: unsure what happens, if the etag headers is already processed by override
+            this.processEtagHeaderParameters(op, httpOperation);
+        }
+    }
+    processSdkMethodOverride(op, sdkMethod) {
+        var _a, _b, _c;
+        // method be called, only if "op.convenienceApi"
+        let request = (_b = (_a = op.convenienceApi) === null || _a === void 0 ? void 0 : _a.requests) === null || _b === void 0 ? void 0 : _b[0];
+        let requestParameters;
+        if (request) {
+            requestParameters = request.parameters;
+        }
+        else {
+            op.convenienceApi.requests = [];
+            request = new Request({
+                protocol: op.requests[0].protocol,
+            });
+            op.convenienceApi.requests.push(request);
+            requestParameters = op.parameters;
+        }
+        request.parameters = [];
+        request.signatureParameters = [];
+        function findOperationParameter(parameter) {
+            let opParameter;
+            // ignore constant parameter, usually the "accept" and "content-type" header
+            if (parameter.type.kind !== "constant") {
+                if (parameter.kind === "body") {
+                    // there should be only 1 body parameter
+                    opParameter = requestParameters.find((it) => { var _a; return ((_a = it.protocol.http) === null || _a === void 0 ? void 0 : _a.in) === "body"; });
+                }
+                else if (parameter.kind === "property") {
+                    // body property
+                    // if body property appears on method signature, it should already be flattened, hence the check on VirtualParameter
+                    opParameter = requestParameters.find((it) => it instanceof VirtualParameter &&
+                        it.language.default.serializedName === getPropertySerializedName(parameter));
+                }
+                else {
+                    // query, path, header
+                    opParameter = requestParameters.find((it) => {
+                        var _a;
+                        return ((_a = it.protocol.http) === null || _a === void 0 ? void 0 : _a.in) === parameter.kind &&
+                            it.language.default.serializedName === parameter.serializedName;
+                    });
+                }
+            }
+            return opParameter;
+        }
+        for (const sdkMethodParameter of sdkMethod.parameters) {
+            let httpOperationParameter = getHttpOperationParameter(sdkMethod, sdkMethodParameter);
+            if (httpOperationParameter) {
+                const opParameter = findOperationParameter(httpOperationParameter);
+                if (opParameter) {
+                    request.signatureParameters.push(opParameter);
+                    request.parameters.push(opParameter);
+                }
+            }
+            else {
+                // sdkMethodParameter is a grouping parameter
+                if (sdkMethodParameter.type.kind === "model") {
+                    const opParameters = [];
+                    for (const property of sdkMethodParameter.type.properties) {
+                        httpOperationParameter = getHttpOperationParameter(sdkMethod, property);
+                        if (httpOperationParameter) {
+                            const opParameter = findOperationParameter(httpOperationParameter);
+                            if (opParameter) {
+                                if (opParameter instanceof VirtualParameter) {
+                                    opParameters.push(opParameter);
+                                }
+                                else {
+                                    opParameters.push(opParameter);
+                                }
+                            }
+                        }
+                    }
+                    // group schema
+                    const groupSchema = this.processGroupSchema(sdkMethodParameter.type, opParameters, sdkMethodParameter.type.name);
+                    this.trackSchemaUsage(groupSchema, { usage: [SchemaContext.Input] });
+                    if (op.convenienceApi) {
+                        this.trackSchemaUsage(groupSchema, {
+                            usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                        });
+                    }
+                    // group parameter
+                    const groupParameter = new Parameter(sdkMethodParameter.name, (_c = sdkMethodParameter.doc) !== null && _c !== void 0 ? _c : "", groupSchema, {
+                        summary: sdkMethodParameter.summary,
+                        implementation: ImplementationLocation.Method,
+                        required: !sdkMethodParameter.optional,
+                        nullable: false,
+                    });
+                    request.signatureParameters.push(groupParameter);
+                    request.parameters.push(...opParameters);
+                    request.parameters.push(groupParameter);
+                    opParameters.forEach((it) => {
+                        it.groupedBy = groupParameter;
+                    });
+                }
+            }
+        }
+    }
+    processGroupSchema(type, parameters, name, description = undefined) {
+        // the "GroupSchema" is simliar to "ObjectSchema", but the process is different
+        var _a, _b;
+        if (type && this.schemaCache.has(type)) {
+            return this.schemaCache.get(type);
+        }
+        // option bag schema
+        const optionBagSchema = this.codeModel.schemas.add(new GroupSchema(name, (_b = (_a = type === null || type === void 0 ? void 0 : type.doc) !== null && _a !== void 0 ? _a : description) !== null && _b !== void 0 ? _b : "", {
+            summary: type === null || type === void 0 ? void 0 : type.summary,
+            language: {
+                default: {
+                    namespace: type ? getNamespace(type.__raw) : this.namespace,
+                },
+                java: {
+                    namespace: this.getJavaNamespace(type),
+                },
+            },
+        }));
+        parameters.forEach((it) => {
+            optionBagSchema.add(new GroupProperty(it.language.default.name, it.language.default.description, it.schema, {
+                originalParameter: [it],
+                summary: it.summary,
+                required: it.required,
+                nullable: it.nullable,
+                readOnly: false,
+                serializedName: it.language.default.serializedName,
+            }));
+        });
+        if (type) {
+            // on cache: the GroupProperty actually has a reference to "originalParameter" (though on same type, the parameter should be identical)
+            this.schemaCache.set(type, optionBagSchema);
+        }
+        return optionBagSchema;
+    }
+    checkGroupingAfterBodyParameterFlatten(op) {
+        var _a, _b;
+        // method be called, only if "op.convenienceApi" is defined
+        // method signature of the convenience API after body parameter flatten
+        const request = (_b = (_a = op.convenienceApi) === null || _a === void 0 ? void 0 : _a.requests) === null || _b === void 0 ? void 0 : _b[0];
+        if (request &&
+            request.signatureParameters &&
+            request.parameters &&
+            request.signatureParameters.length > 6) {
+            // create an option bag
+            const name = op.language.default.name + "Options";
+            const optionBagSchema = this.processGroupSchema(undefined, request.parameters, name, `Options for ${op.language.default.name} API`);
+            this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Input] });
+            if (op.convenienceApi) {
+                this.trackSchemaUsage(optionBagSchema, {
+                    usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
+                });
+            }
+            // option bag parameter
+            const optionBagParameter = new Parameter("options", optionBagSchema.language.default.description, optionBagSchema, {
+                implementation: ImplementationLocation.Method,
+                required: true,
+                nullable: false,
+            });
+            request.signatureParameters = [optionBagParameter];
+            request.parameters.forEach((it) => (it.groupedBy = optionBagParameter));
+            request.parameters.push(optionBagParameter);
+        }
+    }
     processEtagHeaderParameters(op, httpOperation) {
         if (op.convenienceApi && op.parameters && op.signatureParameters) {
             const etagHeadersNames = new Set([
@@ -1054,8 +1254,10 @@ export class CodeModelBuilder {
             }
         }
     }
-    processParameterBody(op, rawHttpOperation, sdkHttpOperation, sdkBody) {
+    processParameterBody(op, sdkMethod, sdkBody) {
         var _a, _b, _c;
+        let bodyParameterFlattened = false;
+        const sdkHttpOperation = sdkMethod.operation;
         // set contentTypes to mediaTypes
         op.requests[0].protocol.http.mediaTypes = sdkBody.contentTypes;
         const unknownRequestBody = op.requests[0].protocol.http.mediaTypes &&
@@ -1097,13 +1299,19 @@ export class CodeModelBuilder {
             this.trackSchemaUsage(schema, { serializationFormats: [KnownMediaType.Multipart] });
         }
         if (op.convenienceApi) {
-            // Explicit body parameter @body or @bodyRoot would result to the existence of rawHttpOperation.parameters.body.property
-            // Implicit body parameter would result to rawHttpOperation.parameters.body.property be undefined
-            // see https://typespec.io/docs/libraries/http/cheat-sheet#data-types
-            const bodyParameterFlatten = schema instanceof ObjectSchema &&
+            /**
+             * Explicit body parameter @body or @bodyRoot would result to the existence of rawHttpOperation.parameters.body.property
+             * Implicit body parameter would result to rawHttpOperation.parameters.body.property be undefined
+             * see https://typespec.io/docs/libraries/http/cheat-sheet#data-types
+             */
+            /**
+             * In TCGC, the condition is 'sdkType.kind === "model" && sdkBody.type !== sdkBody.correspondingMethodParams[0]?.type'.
+             * Basically, it means that the model of the SDK method parameters (typically, more than 1) be different from the model of this single HTTP body parameter.
+             */
+            const bodyParameterFlatten = !this.isArm() &&
+                schema instanceof ObjectSchema &&
                 sdkType.kind === "model" &&
-                !((_c = rawHttpOperation.parameters.body) === null || _c === void 0 ? void 0 : _c.property) &&
-                !this.isArm();
+                sdkBody.type !== ((_c = sdkBody.correspondingMethodParams[0]) === null || _c === void 0 ? void 0 : _c.type);
             if (schema instanceof ObjectSchema && bodyParameterFlatten) {
                 // flatten body parameter
                 const parameters = sdkHttpOperation.parameters;
@@ -1117,8 +1325,10 @@ export class CodeModelBuilder {
                     if (sdkType.isGeneratedName) {
                         schema.language.default.name = pascalCase(op.language.default.name) + "PatchRequest";
                     }
-                    return;
+                    return bodyParameterFlattened;
                 }
+                // flatten body parameter
+                bodyParameterFlattened = true;
                 const schemaUsage = schema.usage;
                 if (!schemaIsPublicBeforeProcess && (schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.includes(SchemaContext.Public))) {
                     // Public added in this op, change it to PublicSpread
@@ -1126,76 +1336,36 @@ export class CodeModelBuilder {
                     schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.splice(schemaUsage === null || schemaUsage === void 0 ? void 0 : schemaUsage.indexOf(SchemaContext.Public), 1);
                     this.trackSchemaUsage(schema, { usage: [SchemaContext.PublicSpread] });
                 }
-                if (op.convenienceApi && op.parameters) {
-                    op.convenienceApi.requests = [];
-                    const request = new Request({
-                        protocol: op.requests[0].protocol,
-                    });
-                    request.parameters = [];
-                    op.convenienceApi.requests.push(request);
-                    // header/query/path params
-                    for (const opParameter of parameters) {
-                        this.addParameterOrBodyPropertyToCodeModelRequest(opParameter, op, request, schema, parameter);
-                    }
-                    // body param
-                    if (bodyParameter) {
-                        if (bodyParameter.type.kind === "model") {
-                            for (const bodyProperty of bodyParameter.type.properties) {
-                                if (bodyProperty.kind === "property") {
-                                    this.addParameterOrBodyPropertyToCodeModelRequest(bodyProperty, op, request, schema, parameter);
-                                }
+                op.convenienceApi.requests = [];
+                const request = new Request({
+                    protocol: op.requests[0].protocol,
+                });
+                request.parameters = [];
+                op.convenienceApi.requests.push(request);
+                // header/query/path params
+                for (const opParameter of parameters) {
+                    this.addParameterOrBodyPropertyToCodeModelRequest(opParameter, op, request, schema, parameter);
+                }
+                // body param
+                if (bodyParameter) {
+                    if (bodyParameter.type.kind === "model") {
+                        for (const bodyProperty of bodyParameter.type.properties) {
+                            if (bodyProperty.kind === "property") {
+                                this.addParameterOrBodyPropertyToCodeModelRequest(bodyProperty, op, request, schema, parameter);
                             }
                         }
                     }
-                    request.signatureParameters = request.parameters;
-                    if (request.signatureParameters.length > 6) {
-                        // create an option bag
-                        const name = op.language.default.name + "Options";
-                        const namespace = getNamespace(rawHttpOperation.operation);
-                        // option bag schema
-                        const optionBagSchema = this.codeModel.schemas.add(new GroupSchema(name, `Options for ${op.language.default.name} API`, {
-                            language: {
-                                default: {
-                                    namespace: namespace,
-                                },
-                                java: {
-                                    namespace: this.getJavaNamespace(),
-                                },
-                            },
-                        }));
-                        request.parameters.forEach((it) => {
-                            optionBagSchema.add(new GroupProperty(it.language.default.name, it.language.default.description, it.schema, {
-                                originalParameter: [it],
-                                summary: it.summary,
-                                required: it.required,
-                                nullable: it.nullable,
-                                readOnly: false,
-                                serializedName: it.language.default.serializedName,
-                            }));
-                        });
-                        this.trackSchemaUsage(optionBagSchema, { usage: [SchemaContext.Input] });
-                        if (op.convenienceApi) {
-                            this.trackSchemaUsage(optionBagSchema, {
-                                usage: [op.internalApi ? SchemaContext.Internal : SchemaContext.Public],
-                            });
-                        }
-                        // option bag parameter
-                        const optionBagParameter = new Parameter("options", optionBagSchema.language.default.description, optionBagSchema, {
-                            implementation: ImplementationLocation.Method,
-                            required: true,
-                            nullable: false,
-                        });
-                        request.signatureParameters = [optionBagParameter];
-                        request.parameters.forEach((it) => (it.groupedBy = optionBagParameter));
-                        request.parameters.push(optionBagParameter);
-                    }
                 }
+                request.signatureParameters = request.parameters;
             }
         }
+        return bodyParameterFlattened;
     }
     addParameterOrBodyPropertyToCodeModelRequest(opParameter, op, request, schema, originalParameter) {
         var _a, _b, _c, _d, _e;
-        const serializedName = opParameter.serializedName;
+        const serializedName = opParameter.kind === "property"
+            ? getPropertySerializedName(opParameter)
+            : opParameter.serializedName;
         let existParameter;
         if (opParameter.kind !== "property") {
             // not body property
@@ -1237,10 +1407,6 @@ export class CodeModelBuilder {
             }
         }
     }
-    findResponseBody(bodyType) {
-        // find a type that possibly without http metadata like @statusCode
-        return this.getEffectiveSchemaType(bodyType);
-    }
     processResponse(op, statusCode, sdkResponse, longRunning, isErrorResponse) {
         var _a;
         // TODO: what to do if more than 1 response?
@@ -1373,6 +1539,7 @@ export class CodeModelBuilder {
         return this.schemaCache.process(type, nameHint) || fail("Unable to process schema.");
     }
     processSchemaImpl(type, nameHint) {
+        var _a;
         if (isSdkBuiltInKind(type.kind)) {
             return this.processBuiltInType(type, nameHint);
         }
@@ -1404,9 +1571,12 @@ export class CodeModelBuilder {
                     }
             }
         }
-        const errorMsg = `Unrecognized type: '${type.kind}'.`;
-        this.logError(errorMsg);
-        throw new Error(errorMsg);
+        const diagnostic = createDiagnostic({
+            code: "unrecognized-type",
+            format: { typeKind: type.kind },
+            target: (_a = type.__raw) !== null && _a !== void 0 ? _a : NoTarget,
+        });
+        throw new DiagnosticError(diagnostic);
     }
     processBuiltInType(type, nameHint) {
         nameHint = nameHint || type.kind;
@@ -1679,26 +1849,8 @@ export class CodeModelBuilder {
         }
         return objectSchema;
     }
-    getEffectiveSchemaType(type) {
-        var _a;
-        const program = this.program;
-        function isSchemaProperty(property) {
-            return isPayloadProperty(program, property);
-        }
-        if (type.kind === "Model") {
-            const effective = getEffectiveModelType(program, type, isSchemaProperty);
-            if (this.isArm() && ((_a = getNamespace(effective)) === null || _a === void 0 ? void 0 : _a.startsWith("Azure.ResourceManager"))) {
-                // e.g. typespec: Catalog is TrackedResource<CatalogProperties>
-                return type;
-            }
-            else if (effective.name) {
-                return effective;
-            }
-        }
-        return type;
-    }
     processModelProperty(prop) {
-        var _a;
+        var _a, _b;
         let nullable = false;
         let nonNullType = prop.type;
         if (nonNullType.kind === "nullable") {
@@ -1722,9 +1874,9 @@ export class CodeModelBuilder {
             extensions = extensions !== null && extensions !== void 0 ? extensions : {};
             extensions["x-ms-mutability"] = mutability;
         }
-        if (prop.kind === "property" && prop.multipartOptions) {
+        if (prop.kind === "property" && prop.serializationOptions.multipart) {
             // TODO: handle MultipartOptions.isMulti
-            if (prop.multipartOptions.isFilePart) {
+            if ((_a = prop.serializationOptions.multipart) === null || _a === void 0 ? void 0 : _a.isFilePart) {
                 schema = this.processMultipartFormDataFilePropertySchema(prop);
             }
             else if (prop.type.kind === "model" &&
@@ -1739,25 +1891,30 @@ export class CodeModelBuilder {
         else {
             schema = this.processSchema(nonNullType, "");
         }
-        return new Property(prop.name, (_a = prop.doc) !== null && _a !== void 0 ? _a : "", schema, {
+        return new Property(prop.name, (_b = prop.doc) !== null && _b !== void 0 ? _b : "", schema, {
             summary: prop.summary,
             required: !prop.optional,
             nullable: nullable,
             readOnly: this.isReadOnly(prop),
-            serializedName: prop.kind === "property" ? prop.serializedName : undefined,
+            serializedName: prop.kind === "property" ? getPropertySerializedName(prop) : undefined,
             extensions: extensions,
         });
     }
     processUnionSchema(type, name) {
-        var _a, _b;
+        var _a, _b, _c;
         if (!(type.__raw && type.__raw.kind === "Union")) {
-            this.logError(`Invalid type for union: '${type.kind}'.`);
+            reportDiagnostic(this.program, {
+                code: "unrecognized-type",
+                messageId: "unionType",
+                format: { typeKind: type.kind },
+                target: (_a = type.__raw) !== null && _a !== void 0 ? _a : NoTarget,
+            });
         }
         const rawUnionType = type.__raw;
         const namespace = getNamespace(rawUnionType);
-        const baseName = (_a = type.name) !== null && _a !== void 0 ? _a : pascalCase(name) + "Model";
-        this.logWarning(`Convert TypeSpec Union '${getUnionDescription(rawUnionType, this.typeNameOptions)}' to Class '${baseName}'`);
-        const unionSchema = new OrSchema(baseName + "Base", (_b = type.doc) !== null && _b !== void 0 ? _b : "", {
+        const baseName = (_b = type.name) !== null && _b !== void 0 ? _b : pascalCase(name) + "Model";
+        this.trace(`Convert TypeSpec Union '${getUnionDescription(rawUnionType, this.typeNameOptions)}' to Class '${baseName}'`);
+        const unionSchema = new OrSchema(baseName + "Base", (_c = type.doc) !== null && _c !== void 0 ? _c : "", {
             summary: type.summary,
         });
         unionSchema.anyOf = [];
@@ -1797,7 +1954,7 @@ export class CodeModelBuilder {
     getUnionVariantName(type, option) {
         var _a, _b;
         if (type === undefined) {
-            this.logWarning("Union variant type is undefined.");
+            this.trace("Union variant type is undefined.");
             return "UnionVariant";
         }
         switch (type.kind) {
@@ -1855,12 +2012,12 @@ export class CodeModelBuilder {
             case "UnionVariant":
                 return (_b = (typeof type.name === "string" ? type.name : undefined)) !== null && _b !== void 0 ? _b : "UnionVariant";
             default:
-                this.logWarning(`Unrecognized type for union variable: '${type.kind}'.`);
+                this.trace(`Unrecognized type for union variable: '${type.kind}'.`);
                 return "UnionVariant";
         }
     }
     processMultipartFormDataFilePropertySchema(property) {
-        var _a;
+        var _a, _b;
         const processSchemaFunc = (type) => this.processSchema(type, "");
         const processNamespaceFunc = (type) => {
             var _a;
@@ -1880,9 +2037,13 @@ export class CodeModelBuilder {
             });
         }
         else {
-            const errorMsg = `Invalid type for multipart form data: '${property.type.kind}'.`;
-            this.logError(errorMsg);
-            throw new Error(errorMsg);
+            const diagnostic = createDiagnostic({
+                code: "unrecognized-type",
+                messageId: "multipartFormData",
+                format: { typeKind: property.type.kind },
+                target: (_b = property.type.__raw) !== null && _b !== void 0 ? _b : NoTarget,
+            });
+            throw new DiagnosticError(diagnostic);
         }
     }
     getDoc(target) {
@@ -1891,21 +2052,6 @@ export class CodeModelBuilder {
     getSummary(target) {
         return target ? getSummary(this.program, target) : undefined;
     }
-    getSerializedName(target) {
-        if (isHeader(this.program, target)) {
-            return getHeaderFieldName(this.program, target);
-        }
-        else if (isQueryParam(this.program, target)) {
-            return getQueryParamName(this.program, target);
-        }
-        else if (isPathParam(this.program, target)) {
-            return getPathParamName(this.program, target);
-        }
-        else {
-            // TODO: currently this is only for JSON
-            return getWireName(this.sdkContext, target);
-        }
-    }
     isReadOnly(target) {
         const segment = target.__raw ? getSegment(this.program, target.__raw) !== undefined : false;
         if (segment) {
@@ -2029,12 +2175,6 @@ export class CodeModelBuilder {
             return clientNamespace.toLowerCase();
         }
     }
-    logError(msg) {
-        logError(this.program, msg);
-    }
-    logWarning(msg) {
-        logWarning(this.program, msg);
-    }
     trace(msg) {
         trace(this.program, msg);
     }
@@ -2084,14 +2224,22 @@ export class CodeModelBuilder {
             },
         });
     }
-    get apiVersionParameter() {
-        return (this._apiVersionParameter ||
-            (this._apiVersionParameter = this.createApiVersionParameter("api-version", ParameterLocation.Query)));
-    }
-    get apiVersionParameterInPath() {
-        return (this._apiVersionParameterInPath ||
-            // TODO: hardcode as "apiVersion", as it is what we get from compiler
-            (this._apiVersionParameterInPath = this.createApiVersionParameter("apiVersion", ParameterLocation.Path)));
+    getApiVersionParameter(param) {
+        // apiVersionParameter is cached by param.kind
+        // we didn't expect Azure service have more than 1 type of api-version, and certainly not more than 1 of each kind.
+        if (param.kind === "query") {
+            return (this._apiVersionParameter ||
+                (this._apiVersionParameter = this.createApiVersionParameter(param.serializedName, ParameterLocation.Query)));
+        }
+        else if (param.kind === "path") {
+            return (this._apiVersionParameterInPath ||
+                (this._apiVersionParameterInPath = this.createApiVersionParameter(param.serializedName, ParameterLocation.Path)));
+        }
+        else {
+            // param.kind === "header"
+            return (this._apiVersionParameterInHeader ||
+                (this._apiVersionParameterInHeader = this.createApiVersionParameter(param.serializedName, ParameterLocation.Header)));
+        }
     }
     isSubscriptionId(param) {
         return "subscriptionId".toLocaleLowerCase() === param.serializedName.toLocaleLowerCase();