@azure-tools/typespec-rust 0.21.0 → 0.23.0

package/dist/src/tcgcadapter/adapter.js

@@ -23,6 +23,12 @@ export class AdapterError extends Error {
         this.target = target !== null && target !== void 0 ? target : NoTarget;
     }
 }
+/**
+ * ExternalError is thrown when an external component reports a
+ * diagnostic error that would prevent the emitter from proceeding.
+ */
+export class ExternalError extends Error {
+}
 /** Adapter converts the tcgc code model to a Rust Crate */
 export class Adapter {
     /**
@@ -40,6 +46,15 @@ export class Adapter {
             disableUsageAccessPropagationToBase: true,
         });
         context.program.reportDiagnostics(ctx.diagnostics);
+        for (const diag of ctx.diagnostics) {
+            if (diag.severity === 'error') {
+                // there's no point in continuing if tcgc
+                // has reported diagnostic errors, so exit.
+                // this prevents spurious crashes in the
+                // emitter as our input state is invalid.
+                throw new ExternalError();
+            }
+        }
         return new Adapter(ctx, context.options);
     }
     constructor(ctx, options) {
@@ -66,25 +81,6 @@ export class Adapter {
         if (this.crate.clients.length > 0 || this.crate.enums.length > 0 || this.crate.models.length > 0) {
             this.crate.addDependency(new rust.CrateDependency('typespec_client_core', ['derive']));
         }
-        // TODO: remove once https://github.com/Azure/typespec-rust/issues/22 is fixed
-        for (const client of this.crate.clients) {
-            let done = false;
-            for (const method of client.methods) {
-                if (method.kind === 'pageable') {
-                    if (method.returns.type.kind === 'pager') {
-                        this.crate.addDependency(new rust.CrateDependency('async-trait')); // required for azure_core::http::Page trait
-                    }
-                    // TODO: why is this here?
-                    this.crate.addDependency(new rust.CrateDependency('futures'));
-                    done = true;
-                    break;
-                }
-            }
-            if (done) {
-                break;
-            }
-        }
-        // end TODO
         this.crate.sortContent();
         return this.crate;
     }
@@ -132,6 +128,7 @@ export class Adapter {
      * @returns a Rust enum
      */
     getEnum(sdkEnum) {
+        var _a;
         const enumName = codegen.capitalize(sdkEnum.name);
         let rustEnum = this.types.get(enumName);
         if (rustEnum) {
@@ -140,8 +137,15 @@ export class Adapter {
         rustEnum = new rust.Enum(enumName, sdkEnum.access === 'public', !sdkEnum.isFixed);
         rustEnum.docs = this.adaptDocs(sdkEnum.summary, sdkEnum.doc);
         this.types.set(enumName, rustEnum);
+        const rustEnumNameToSdkEnumName = new Map();
         for (const value of sdkEnum.values) {
-            const rustEnumValue = new rust.EnumValue(helpers.fixUpEnumValueName(value), rustEnum, value.value);
+            const enumValueName = naming.fixUpEnumValueName(value);
+            const existingMapping = rustEnumNameToSdkEnumName.get(enumValueName);
+            if (existingMapping) {
+                throw new AdapterError('NameCollision', `enum values ${value.name} and ${existingMapping} coalesce into the same name ${enumValueName}`, (_a = sdkEnum.__raw) === null || _a === void 0 ? void 0 : _a.node);
+            }
+            rustEnumNameToSdkEnumName.set(enumValueName, value.name);
+            const rustEnumValue = new rust.EnumValue(enumValueName, rustEnum, value.value);
             rustEnumValue.docs = this.adaptDocs(value.summary, value.doc);
             rustEnum.values.push(rustEnumValue);
         }
@@ -159,7 +163,7 @@ export class Adapter {
         const enumType = this.getEnum(sdkEnumValue.enumType);
         // find the specified enum value
         for (const value of enumType.values) {
-            if (value.name === helpers.fixUpEnumValueName(sdkEnumValue)) {
+            if (value.name === naming.fixUpEnumValueName(sdkEnumValue)) {
                 return value;
             }
         }
@@ -673,7 +677,7 @@ export class Adapter {
         var _a, _b, _c, _d, _e;
         let clientName = client.name;
         // NOTE: if the client has the @clientName decorator applied then use that verbatim
-        if (parent && !client.decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@clientName')) {
+        if (parent && !hasClientNameDecorator(client.decorators)) {
             // for hierarchical clients, the child client names are built
             // from the parent client name. this is because tsp allows subclients
             // with the same name. consider the following example.
@@ -787,12 +791,13 @@ export class Adapter {
                             if (i === 0) {
                                 // the first template arg is always the endpoint parameter.
                                 // note that the types of the param and the field are different.
-                                // NOTE: we use param.name here instead of templateArg.name as
-                                // the former has the fixed name "endpoint" which is what we want.
-                                const adaptedParam = new rust.ClientMethodParameter(param.name, this.getRefType(this.getStringSlice()), false);
+                                // we default to "endpoint" and will use the defined name IFF
+                                // it has the @clientName decorator applied
+                                const endpointName = hasClientNameDecorator(templateArg.decorators) ? snakeCaseName(templateArg.name) : 'endpoint';
+                                const adaptedParam = new rust.ClientEndpointParameter(endpointName);
                                 adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
                                 ctorParams.push(adaptedParam);
-                                rustClient.fields.push(new rust.StructField(param.name, 'pubCrate', new rust.Url(this.crate)));
+                                rustClient.fields.push(new rust.StructField(endpointName, 'pubCrate', new rust.Url(this.crate)));
                                 // if the server's URL is *only* the endpoint parameter then we're done.
                                 // this is the param.type.kind === 'endpoint' case.
                                 if (endpointType.serverUrl === `{${templateArg.serializedName}}`) {
@@ -817,7 +822,7 @@ export class Adapter {
                                 continue;
                             }
                             const clientParam = this.adaptClientParameter(templateArg, rustClient.constructable);
-                            if (clientParam.kind !== 'clientEndpoint') {
+                            if (clientParam.kind !== 'clientSupplementalEndpoint') {
                                 throw new AdapterError('InternalError', `unexpected client parameter kind ${clientParam.kind}`, (_b = templateArg.__raw) === null || _b === void 0 ? void 0 : _b.node);
                             }
                             (_c = rustClient.constructable.endpoint) === null || _c === void 0 ? void 0 : _c.parameters.push(clientParam);
@@ -910,7 +915,7 @@ export class Adapter {
             throw new AdapterError('InternalError', 'scopes must contain at least one entry', cred.model);
         }
         const ctorTokenCredential = new rust.Constructor('new');
-        const tokenCredParam = new rust.ClientMethodParameter('credential', new rust.Arc(new rust.TokenCredential(this.crate, scopes)), false);
+        const tokenCredParam = new rust.ClientCredentialParameter('credential', new rust.Arc(new rust.TokenCredential(this.crate, scopes)));
         tokenCredParam.docs.summary = `An implementation of [\`TokenCredential\`](azure_core::credentials::TokenCredential) that can provide an Entra ID token to use when authenticating.`;
         ctorTokenCredential.params.push(tokenCredParam);
         ctorTokenCredential.docs.summary = `Creates a new ${rustClient.name}, using Entra ID authentication.`;
@@ -957,7 +962,7 @@ export class Adapter {
                 adaptedParam = new rust.ClientMethodParameter(paramName, paramType, optional);
                 break;
             case 'path':
-                adaptedParam = new rust.ClientEndpointParameter(paramName, paramType, optional, param.serializedName);
+                adaptedParam = new rust.ClientSupplementalEndpointParameter(paramName, paramType, optional, param.serializedName);
                 break;
         }
         adaptedParam.docs = this.adaptDocs(param.summary, param.doc);
@@ -1160,6 +1165,21 @@ export class Adapter {
             }
             return this.adaptPayloadFormatType(defaultContentType);
         };
+        const getStatusCodes = function (httpOp) {
+            const statusCodes = new Array();
+            for (const response of httpOp.responses) {
+                const statusCode = response.statusCodes;
+                if (isHttpStatusCodeRange(statusCode)) {
+                    for (let code = statusCode.start; code <= statusCode.end; ++code) {
+                        statusCodes.push(code);
+                    }
+                }
+                else {
+                    statusCodes.push(statusCode);
+                }
+            }
+            return statusCodes;
+        };
         // add any response headers
         const responseHeaders = new Array();
         for (const httpResp of method.operation.responses) {
@@ -1260,6 +1280,7 @@ export class Adapter {
                 rustMethod.returns = new rust.Result(this.crate, new rust.PageIterator(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
             }
             else {
+                this.crate.addDependency(new rust.CrateDependency('async-trait'));
                 rustMethod.returns = new rust.Result(this.crate, new rust.Pager(this.crate, new rust.Response(this.crate, synthesizedModel, responseFormat)));
             }
         }
@@ -1300,11 +1321,20 @@ export class Adapter {
         }
         else if (method.response.type && method.response.type.kind === 'bytes' && method.response.type.encode === 'bytes') {
             // bytes encoding indicates a streaming binary response
-            rustMethod.returns = new rust.Result(this.crate, new rust.RawResponse(this.crate));
+            rustMethod.returns = new rust.Result(this.crate, new rust.BufResponse(this.crate));
         }
         else {
             rustMethod.returns = new rust.Result(this.crate, new rust.Response(this.crate, this.getUnitType(), responseFormat));
         }
+        // Mark the set of success status codes expected from this method.
+        rustMethod.statusCodes = getStatusCodes(method.operation);
+        // For long running operations, we add 200 OK if not already present for the LRO polling and terminal states.
+        if (method.kind === 'lro') {
+            if (!rustMethod.statusCodes.includes(200)) {
+                rustMethod.statusCodes.push(200);
+            }
+        }
+        rustMethod.statusCodes.sort((a, b) => a - b);
         const responseHeadersMap = this.adaptResponseHeaders(responseHeaders);
         rustMethod.responseHeaders = this.adaptResponseHeadersTrait(rustClient, rustMethod, Array.from(responseHeadersMap.values()));
         if (method.kind === 'paging') {
@@ -1397,7 +1427,7 @@ export class Adapter {
                 implFor = method.returns.type;
                 break;
             default:
-                // this is RawResponse which should have been previously skipped
+                // this is BufResponse which should have been previously skipped
                 throw new AdapterError('InternalError', `unexpected method return kind ${method.returns.type.kind}`);
         }
         const traitName = `${recursiveTypeName(implFor.content)}Headers`;
@@ -1416,35 +1446,32 @@ export class Adapter {
      * @returns the pageable strategy
      */
     adaptPageableMethodStrategy(method, paramsMap, respHeadersMap) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _a, _b, _c, _d, _e;
+        const buildNextLinkPath = (segments) => {
+            var _a, _b;
+            // build the field path for the next link segments
+            const nextLinkPath = new Array();
+            for (const segment of segments) {
+                if (segment.kind !== 'property') {
+                    throw new AdapterError('InternalError', `unexpected kind ${segment.kind} for next link segment in operation ${method.name}`, (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
+                }
+                const nextLinkField = this.fieldsMap.get(segment);
+                if (!nextLinkField) {
+                    // the most likely explanation for this is lack of reference equality
+                    throw new AdapterError('InternalError', `missing next link field name ${segment.name} for operation ${method.name}`, (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
+                }
+                nextLinkPath.push(nextLinkField);
+            }
+            return nextLinkPath;
+        };
         if (method.pagingMetadata.nextLinkOperation) {
             // TODO: https://github.com/Azure/autorest.rust/issues/103
             throw new AdapterError('UnsupportedTsp', 'next page operation NYI', (_a = method.__raw) === null || _a === void 0 ? void 0 : _a.node);
         }
         else if (method.pagingMetadata.nextLinkSegments) {
-            if (method.pagingMetadata.nextLinkSegments.length > 1) {
-                // TODO: https://github.com/Azure/autorest.rust/issues/102
-                throw new AdapterError('UnsupportedTsp', 'nested next link path NYI', (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
-            }
-            // this is the field in the response type that contains the next link URL
-            const nextLinkSegment = method.pagingMetadata.nextLinkSegments[0];
-            if (nextLinkSegment.kind !== 'property') {
-                throw new AdapterError('InternalError', `unexpected kind ${nextLinkSegment.kind} for next link segment in operation ${method.name}`, (_c = method.__raw) === null || _c === void 0 ? void 0 : _c.node);
-            }
-            const nextLinkField = this.fieldsMap.get(nextLinkSegment);
-            if (!nextLinkField) {
-                // the most likely explanation for this is lack of reference equality
-                throw new AdapterError('InternalError', `missing next link field name ${nextLinkSegment.name} for operation ${method.name}`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
-            }
-            return new rust.PageableStrategyNextLink(nextLinkField);
+            return new rust.PageableStrategyNextLink(buildNextLinkPath(method.pagingMetadata.nextLinkSegments));
         }
         else if (method.pagingMetadata.continuationTokenParameterSegments && method.pagingMetadata.continuationTokenResponseSegments) {
-            if (method.pagingMetadata.continuationTokenParameterSegments.length > 1) {
-                throw new AdapterError('UnsupportedTsp', `nested continuationTokenParameterSegments NYI`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
-            }
-            if (method.pagingMetadata.continuationTokenResponseSegments.length > 1) {
-                throw new AdapterError('UnsupportedTsp', `nested continuationTokenResponseSegments NYI`, (_f = method.__raw) === null || _f === void 0 ? void 0 : _f.node);
-            }
             const tokenReq = method.pagingMetadata.continuationTokenParameterSegments[0];
             const tokenResp = method.pagingMetadata.continuationTokenResponseSegments[0];
             // find the continuation token parameter
@@ -1453,29 +1480,25 @@ export class Adapter {
                 case 'method': {
                     const tokenParam = paramsMap.get(tokenReq);
                     if (!tokenParam) {
-                        throw new AdapterError('InternalError', `missing continuation token request parameter name ${tokenResp.name} for operation ${method.name}`, (_g = method.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                        throw new AdapterError('InternalError', `missing continuation token request parameter name ${tokenResp.name} for operation ${method.name}`, (_b = method.__raw) === null || _b === void 0 ? void 0 : _b.node);
                     }
                     requestToken = tokenParam;
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, (_h = tokenReq.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                    throw new AdapterError('InternalError', `unhandled continuationTokenParameterSegment kind ${tokenReq.kind}`, (_c = tokenReq.__raw) === null || _c === void 0 ? void 0 : _c.node);
             }
             // find the continuation token response
             let responseToken;
             switch (tokenResp.kind) {
                 case 'property': {
-                    const tokenField = this.fieldsMap.get(tokenResp);
-                    if (!tokenField) {
-                        throw new AdapterError('InternalError', `missing continuation token response field name ${tokenResp.name} for operation ${method.name}`, (_j = method.__raw) === null || _j === void 0 ? void 0 : _j.node);
-                    }
-                    responseToken = tokenField;
+                    responseToken = new rust.PageableStrategyNextLink(buildNextLinkPath(method.pagingMetadata.continuationTokenResponseSegments));
                     break;
                 }
                 case 'responseheader': {
                     const tokenHeader = respHeadersMap.get(tokenResp);
                     if (!tokenHeader) {
-                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${method.name}`, (_k = method.__raw) === null || _k === void 0 ? void 0 : _k.node);
+                        throw new AdapterError('InternalError', `missing continuation token response header name ${tokenResp.name} for operation ${method.name}`, (_d = method.__raw) === null || _d === void 0 ? void 0 : _d.node);
                     }
                     if (tokenHeader.kind !== 'responseHeaderScalar') {
                         throw new AdapterError('InternalError', `unexpected response header kind ${tokenHeader.kind}`);
@@ -1484,12 +1507,13 @@ export class Adapter {
                     break;
                 }
                 default:
-                    throw new AdapterError('InternalError', `missing continuation token`, (_l = method.__raw) === null || _l === void 0 ? void 0 : _l.node);
+                    throw new AdapterError('InternalError', `missing continuation token`, (_e = method.__raw) === null || _e === void 0 ? void 0 : _e.node);
             }
             return new rust.PageableStrategyContinuationToken(requestToken, responseToken);
         }
         else {
-            throw new AdapterError('InternalError', `unknown paging strategy for operation ${method.name}`, (_m = method.__raw) === null || _m === void 0 ? void 0 : _m.node);
+            // operation is pageable but doesn't yet support fetching subsequent pages
+            return undefined;
         }
     }
     /**
@@ -1959,4 +1983,16 @@ function getXMLKind(decorators, field) {
     }
     return undefined;
 }
+/**
+ * returns true if decorators contains `@clientName`
+ *
+ * @param decorators the array of decorators to inspect
+ * @returns true if `@clientName` is found in decorators
+ */
+function hasClientNameDecorator(decorators) {
+    return decorators.find((decorator) => decorator.name === 'Azure.ClientGenerator.Core.@clientName') !== undefined;
+}
+function isHttpStatusCodeRange(statusCode) {
+    return statusCode.start !== undefined;
+}
 //# sourceMappingURL=adapter.js.map