@azure-tools/typespec-rust 0.38.0 → 0.39.0

package/dist/src/tcgcadapter/adapter.js

@@ -222,7 +222,6 @@ export class Adapter {
             };
             terminalErrorModelNames = getTerminalErrorModelNames(this.ctx.sdkPackage.clients);
         }
-        const processedTypes = new Set();
         for (const model of this.ctx.sdkPackage.models) {
             if ((model.usage & (tcgc.UsageFlags.Input | tcgc.UsageFlags.Output | tcgc.UsageFlags.Spread | tcgc.UsageFlags.Exception)) === 0) {
                 // skip types without input and output usage. this will include core
@@ -236,15 +235,7 @@ export class Adapter {
                 continue;
             }
             needsCoreAndSerde = true;
-            // TODO: workaround for https://github.com/Azure/typespec-azure/issues/3614
-            if (processedTypes.has(model.name)) {
-                continue;
-            }
-            else {
-                processedTypes.add(model.name);
-            }
-            // END workaround
-            if (model.discriminatedSubtypes) {
+            if (isPolymorphicRoot(model)) {
                 const rustUnion = this.getDiscriminatedUnion(model);
                 this.adaptNamespace(model.namespace).unions.push(rustUnion);
                 // we don't want to add the base type to the array
@@ -426,7 +417,7 @@ export class Adapter {
         // aggregate the properties from the provided type and its parent types
         const allProps = new Array();
         for (const prop of model.properties) {
-            if (prop.discriminator && !model.discriminatedSubtypes) {
+            if (prop.discriminator && !isPolymorphicRoot(model)) {
                 rustModel.flags |= rust.ModelFlags.PolymorphicSubtype;
             }
             allProps.push(prop);
@@ -492,7 +483,7 @@ export class Adapter {
      * @returns a Rust union
      */
     getDiscriminatedUnion(src) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         if (src.name.length === 0) {
             throw new AdapterError('InternalError', 'unnamed union', (_a = src.__raw) === null || _a === void 0 ? void 0 : _a.node);
         }
@@ -504,7 +495,7 @@ export class Adapter {
         }
         switch (src.kind) {
             case 'model': {
-                if (!src.discriminatedSubtypes) {
+                if (!isPolymorphicRoot(src)) {
                     // we should have verified this earlier.
                     // having this check means the compiler won't bark
                     // at us when accessing src.discriminatedSubtypes
@@ -553,9 +544,10 @@ export class Adapter {
                     }
                     rustUnion.unionKind = new rust.DiscriminatedUnionBase(baseModel);
                 }
-                for (const subType of Object.values(src.discriminatedSubtypes)) {
+                // we need to handle the case where src is a root with no child types
+                for (const subType of Object.values((_e = src.discriminatedSubtypes) !== null && _e !== void 0 ? _e : {})) {
                     if (!subType.discriminatorValue) {
-                        throw new AdapterError('InternalError', `model ${subType.name} has no discriminator value`, (_e = subType.__raw) === null || _e === void 0 ? void 0 : _e.node);
+                        throw new AdapterError('InternalError', `model ${subType.name} has no discriminator value`, (_f = subType.__raw) === null || _f === void 0 ? void 0 : _f.node);
                     }
                     const unionMemberType = subType.discriminatedSubtypes ? this.getDiscriminatedUnion(subType) : this.getModel(subType);
                     const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, subType.discriminatorValue);
@@ -568,7 +560,7 @@ export class Adapter {
                     // we should have verified this earlier.
                     // having this check means the compiler won't bark
                     // at us when accessing src.discriminatedOptions
-                    throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_f = src.__raw) === null || _f === void 0 ? void 0 : _f.node);
+                    throw new AdapterError('InternalError', 'getDiscriminatedUnion called for non-discriminated union', (_g = src.__raw) === null || _g === void 0 ? void 0 : _g.node);
                 }
                 rustUnion = new rust.DiscriminatedUnion(unionName, adaptAccessFlags(src.access), src.discriminatedOptions.discriminatorPropertyName, this.adaptNamespace(src.namespace));
                 if (src.discriminatedOptions.envelopePropertyName) {
@@ -591,12 +583,12 @@ export class Adapter {
                 // END WORKAROUND
                 for (const unionMember of src.variantTypes) {
                     if (unionMember.kind !== 'model') {
-                        throw new AdapterError('UnsupportedTsp', `non-model union member kind ${unionMember.kind}`, (_g = unionMember.__raw) === null || _g === void 0 ? void 0 : _g.node);
+                        throw new AdapterError('UnsupportedTsp', `non-model union member kind ${unionMember.kind}`, (_h = unionMember.__raw) === null || _h === void 0 ? void 0 : _h.node);
                     }
                     // TODO: use unionMember.discriminatorValue
                     const discriminatorValue = discriminatorValues.get(unionMember.name);
                     if (!discriminatorValue) {
-                        throw new AdapterError('InternalError', `didn't find discriminant value for type ${unionMember.name}`, (_h = unionMember.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                        throw new AdapterError('InternalError', `didn't find discriminant value for type ${unionMember.name}`, (_j = unionMember.__raw) === null || _j === void 0 ? void 0 : _j.node);
                     }
                     const unionMemberType = this.getModel(unionMember);
                     const rustUnionMember = new rust.DiscriminatedUnionMember(unionMemberType, discriminatorValue);
@@ -854,6 +846,9 @@ export class Adapter {
             }
             modelField.docs.description += `Operational visibility: ${visibilityStr}`;
         }
+        if (property.visibility && property.visibility.length === 1 && property.visibility[0] === http.Visibility.Read) {
+            modelField.flags |= rust.ModelFieldFlags.ReadOnly;
+        }
         // if this is a literal, add a doc comment explaining its behavior
         const unwrappedType = utils.unwrapOption(fieldType);
         if (unwrappedType.kind === 'enumValue' || unwrappedType.kind === 'literal') {
@@ -960,6 +955,11 @@ export class Adapter {
             }
             case 'constant':
                 return this.getLiteral(type);
+            // Per https://typespec.io/docs/language-basics/built-in-types/:
+            // "Parent type for all numeric types" - decimal fits the best.
+            // No Azure spec, no Spector test uses this type, we only need it here for spector/tcgc/alternate-type test,
+            // but only until https://github.com/Azure/typespec-azure/issues/3965 is fixed.
+            case 'numeric':
             case 'decimal':
             case 'decimal128': {
                 const keyName = 'decimal' + (type.encode ? `-${type.encode}` : '');
@@ -1008,7 +1008,7 @@ export class Adapter {
                 if (type.external) {
                     return this.getExternalType(type.external);
                 }
-                else if (type.discriminatedSubtypes) {
+                else if (isPolymorphicRoot(type)) {
                     return this.getDiscriminatedUnion(type);
                 }
                 else if (tcgc.isAzureCoreModel(type)) {
@@ -2441,7 +2441,7 @@ export class Adapter {
      * @returns a Rust method parameter
      */
     adaptMethodParameter(opParam, methodParam, lifetime) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         /**
          * used to create keys for this.clientMethodParams
          * @param param the param for which to create a key
@@ -2570,6 +2570,12 @@ export class Adapter {
                                 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, opParam.serializedName, paramLoc, paramOptional, paramType, opParam.allowReserved, style);
+                        const allowEmpty = ((_h = opParam.decorators.find(d => d.name === 'Azure.ClientGenerator.Core.@clientOption'
+                            && d.arguments['name'] === 'allowEmpty'
+                            && d.arguments['scope'] === 'rust')) === null || _h === void 0 ? void 0 : _h.arguments['value']) === true;
+                        if (allowEmpty) {
+                            adaptedParam.minLength = 0;
+                        }
                     }
                 }
                 break;
@@ -2593,7 +2599,7 @@ export class Adapter {
                         case 'model':
                         case 'slice':
                         case 'str':
-                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${opParam.serializedName}`, (_h = opParam.__raw) === null || _h === void 0 ? void 0 : _h.node);
+                            throw new AdapterError('InternalError', `unexpected kind ${paramType.kind} for scalar query ${opParam.serializedName}`, (_j = opParam.__raw) === null || _j === void 0 ? void 0 : _j.node);
                     }
                     // TODO: hard-coded encoding setting, https://github.com/Azure/typespec-azure/issues/1314
                     adaptedParam = new rust.QueryScalarParameter(paramName, opParam.serializedName, paramLoc, paramOptional, paramType, true);
@@ -3009,4 +3015,23 @@ function typeToRefType(type) {
             throw new AdapterError('InternalError', `cannot convert ${type.kind} to a ref type`);
     }
 }
+/**
+ * returns true if model is a polymorphic root type.
+ *
+ * @param model the model to inspect
+ * @returns true if the model is a polymorphic root
+ */
+function isPolymorphicRoot(model) {
+    if (model.discriminatedSubtypes) {
+        // when there are sub-types we know for sure it's a polymorphic root
+        return true;
+    }
+    else if (model.discriminatorProperty && !model.discriminatorValue) {
+        // we can land here if it's a root but has no child types
+        return true;
+    }
+    else {
+        return false;
+    }
+}
 //# sourceMappingURL=adapter.js.map