Support decimal type in RLC (#2170)

* Support decimal type in RLC

* Update the test codes

* Re-generate the test and enable decimal cases

* Update the test cases for decimal

* Update the wordings

* update the test cases

* Update the UTs for test cases

packages/typespec-ts/package.json

@@ -58,7 +58,7 @@
     "ts-node": "~10.9.1",
     "typescript": "~5.2.0",
     "prettier": "~2.7.1",
-    "@azure-tools/cadl-ranch-specs": "^0.26.1",
+    "@azure-tools/cadl-ranch-specs": "^0.26.2",
     "@azure-tools/cadl-ranch-expect": "^0.9.0",
     "@azure-tools/cadl-ranch": "^0.10.0",
     "chalk": "^4.0.0",

packages/typespec-ts/src/lib.ts

@@ -198,6 +198,12 @@ const libDef = {
       messages: {
         default: paramMessage`Please specify @items property for the paging operation - ${"operationName"}.`
       }
+    },
+    "decimal-to-number": {
+      severity: "warning",
+      messages: {
+        default: paramMessage`Please note the decimal type will be converted to number. If you strongly care about precision you can use @encode to encode it as a string for the property - ${"propertyName"}.`
+      }
     }
   },
   emitter: {

packages/typespec-ts/src/utils/modelUtils.ts

@@ -1052,7 +1052,7 @@ function getSchemaForStdScalar(
     case "safeint":
       return applyIntrinsicDecorators(program, type, {
         type: "number",
-        format: "int64"
+        format: "safeint"
       });
     case "uint8":
       return applyIntrinsicDecorators(program, type, {
@@ -1077,18 +1077,44 @@ function getSchemaForStdScalar(
     case "float64":
       return applyIntrinsicDecorators(program, type, {
         type: "number",
-        format: "double"
+        format: "float64"
       });
     case "float32":
       return applyIntrinsicDecorators(program, type, {
         type: "number",
-        format: "float"
+        format: "float32"
       });
     case "float":
       return applyIntrinsicDecorators(program, type, {
         type: "number",
         format: "float"
       });
+    case "decimal":
+      reportDiagnostic(program, {
+        code: "decimal-to-number",
+        format: {
+          propertyName: relevantProperty?.name ?? ""
+        },
+        target: relevantProperty ?? type
+      });
+      return applyIntrinsicDecorators(program, type, {
+        type: "number",
+        format: "decimal",
+        description: "decimal"
+      });
+    case "decimal128":
+      reportDiagnostic(program, {
+        code: "decimal-to-number",
+        format: {
+          propertyName: relevantProperty?.name ?? ""
+        },
+        target: relevantProperty ?? type
+      });
+      return applyIntrinsicDecorators(program, type, {
+        type: "number",
+        format: "decimal128",
+        description: "decimal128"
+      });
     case "string":
       if (format === "binary") {
         return {
@@ -1243,14 +1269,30 @@ function getEnumStringDescription(type: any) {
   return undefined;
 }
 
+function getDecimalDescription(type: any) {
+  if (
+    (type.format === "decimal" || type.format === "decimal128") &&
+    type.type === "number"
+  ) {
+    return `NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   `;
+  }
+  return undefined;
+}
+
 export function getFormattedPropertyDoc(
   program: Program,
   type: ModelProperty | Type,
   schemaType: any,
   sperator: string = "\n\n"
 ) {
   const propertyDoc = getDoc(program, type);
-  const enhancedDocFromType = getEnumStringDescription(schemaType);
+  const enhancedDocFromType =
+    getEnumStringDescription(schemaType) ?? getDecimalDescription(schemaType);
   if (propertyDoc && enhancedDocFromType) {
     return `${propertyDoc}${sperator}${enhancedDocFromType}`;
   }

packages/typespec-ts/test/integration/generated/models/propertyTypes/src/clientDefinitions.ts

@@ -12,6 +12,10 @@ import {
   IntPutParameters,
   FloatGetParameters,
   FloatPutParameters,
+  DecimalGetParameters,
+  DecimalPutParameters,
+  Decimal128GetParameters,
+  Decimal128PutParameters,
   DatetimeGetParameters,
   DatetimePutParameters,
   DurationGetParameters,
@@ -66,6 +70,10 @@ import {
   IntPut204Response,
   FloatGet200Response,
   FloatPut204Response,
+  DecimalGet200Response,
+  DecimalPut204Response,
+  Decimal128Get200Response,
+  Decimal128Put204Response,
   DatetimeGet200Response,
   DatetimePut204Response,
   DurationGet200Response,
@@ -154,6 +162,24 @@ export interface FloatGet {
   put(options: FloatPutParameters): StreamableMethod<FloatPut204Response>;
 }
 
+export interface DecimalGet {
+  /** Get call */
+  get(options?: DecimalGetParameters): StreamableMethod<DecimalGet200Response>;
+  /** Put operation */
+  put(options: DecimalPutParameters): StreamableMethod<DecimalPut204Response>;
+}
+
+export interface Decimal128Get {
+  /** Get call */
+  get(
+    options?: Decimal128GetParameters
+  ): StreamableMethod<Decimal128Get200Response>;
+  /** Put operation */
+  put(
+    options: Decimal128PutParameters
+  ): StreamableMethod<Decimal128Put204Response>;
+}
+
 export interface DatetimeGet {
   /** Get call */
   get(
@@ -380,6 +406,10 @@ export interface Routes {
   (path: "/type/property/value-types/int"): IntGet;
   /** Resource for '/type/property/value-types/float' has methods for the following verbs: get, put */
   (path: "/type/property/value-types/float"): FloatGet;
+  /** Resource for '/type/property/value-types/decimal' has methods for the following verbs: get, put */
+  (path: "/type/property/value-types/decimal"): DecimalGet;
+  /** Resource for '/type/property/value-types/decimal128' has methods for the following verbs: get, put */
+  (path: "/type/property/value-types/decimal128"): Decimal128Get;
   /** Resource for '/type/property/value-types/datetime' has methods for the following verbs: get, put */
   (path: "/type/property/value-types/datetime"): DatetimeGet;
   /** Resource for '/type/property/value-types/duration' has methods for the following verbs: get, put */

packages/typespec-ts/test/integration/generated/models/propertyTypes/src/models.ts

@@ -31,6 +31,36 @@ export interface FloatProperty {
   property: number;
 }
 
+/** Model with a decimal property */
+export interface DecimalProperty {
+  /**
+   * Property
+   *
+   * NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+   * Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+   * If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+   * For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+   * Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   *
+   */
+  property: number;
+}
+
+/** Model with a decimal128 property */
+export interface Decimal128Property {
+  /**
+   * Property
+   *
+   * NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+   * Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+   * If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+   * For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+   * Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   *
+   */
+  property: number;
+}
+
 /** Model with a datetime property */
 export interface DatetimeProperty {
   /** Property */

packages/typespec-ts/test/integration/generated/models/propertyTypes/src/outputModels.ts

@@ -31,6 +31,36 @@ export interface FloatPropertyOutput {
   property: number;
 }
 
+/** Model with a decimal property */
+export interface DecimalPropertyOutput {
+  /**
+   * Property
+   *
+   * NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+   * Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+   * If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+   * For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+   * Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   *
+   */
+  property: number;
+}
+
+/** Model with a decimal128 property */
+export interface Decimal128PropertyOutput {
+  /**
+   * Property
+   *
+   * NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
+   * Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
+   * If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
+   * For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
+   * Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
+   *
+   */
+  property: number;
+}
+
 /** Model with a datetime property */
 export interface DatetimePropertyOutput {
   /** Property */

packages/typespec-ts/test/integration/generated/models/propertyTypes/src/parameters.ts

@@ -8,6 +8,8 @@ import {
   BytesProperty,
   IntProperty,
   FloatProperty,
+  DecimalProperty,
+  Decimal128Property,
   DatetimeProperty,
   DurationProperty,
   EnumProperty,
@@ -73,6 +75,23 @@ export interface FloatPutBodyParam {
 }
 
 export type FloatPutParameters = FloatPutBodyParam & RequestParameters;
+export type DecimalGetParameters = RequestParameters;
+
+export interface DecimalPutBodyParam {
+  /** body */
+  body: DecimalProperty;
+}
+
+export type DecimalPutParameters = DecimalPutBodyParam & RequestParameters;
+export type Decimal128GetParameters = RequestParameters;
+
+export interface Decimal128PutBodyParam {
+  /** body */
+  body: Decimal128Property;
+}
+
+export type Decimal128PutParameters = Decimal128PutBodyParam &
+  RequestParameters;
 export type DatetimeGetParameters = RequestParameters;
 
 export interface DatetimePutBodyParam {

packages/typespec-ts/test/integration/generated/models/propertyTypes/src/responses.ts

@@ -8,6 +8,8 @@ import {
   BytesPropertyOutput,
   IntPropertyOutput,
   FloatPropertyOutput,
+  DecimalPropertyOutput,
+  Decimal128PropertyOutput,
   DatetimePropertyOutput,
   DurationPropertyOutput,
   EnumPropertyOutput,
@@ -86,6 +88,28 @@ export interface FloatPut204Response extends HttpResponse {
   status: "204";
 }
 
+/** The request has succeeded. */
+export interface DecimalGet200Response extends HttpResponse {
+  status: "200";
+  body: DecimalPropertyOutput;
+}
+
+/** There is no content to send for this request, but the headers may be useful. */
+export interface DecimalPut204Response extends HttpResponse {
+  status: "204";
+}
+
+/** The request has succeeded. */
+export interface Decimal128Get200Response extends HttpResponse {
+  status: "200";
+  body: Decimal128PropertyOutput;
+}
+
+/** There is no content to send for this request, but the headers may be useful. */
+export interface Decimal128Put204Response extends HttpResponse {
+  status: "204";
+}
+
 /** The request has succeeded. */
 export interface DatetimeGet200Response extends HttpResponse {
   status: "200";