feat(type-info): preserve object-literal as const properties (#10143)

Author: minseong0324

.changeset/no-misleading-return-type-as-const-property.md

@@ -0,0 +1,13 @@
+---
+"@biomejs/biome": patch
+---
+
+[`noMisleadingReturnType`](https://biomejs.dev/linter/rules/no-misleading-return-type/) now detects misleading return type annotations when object literal properties are initialized with `as const`.
+
+This function is now reported because the return annotation widens a property initialized with `as const`:
+
+```ts
+function f(): { value: string } {
+	return { value: "text" as const };
+}
+```

.changeset/no-useless-type-conversion-as-const-property.md

@@ -0,0 +1,12 @@
+---
+"@biomejs/biome": patch
+---
+
+[`noUselessTypeConversion`](https://biomejs.dev/linter/rules/no-useless-type-conversion/) now detects redundant conversions on object literal properties initialized with `as const`.
+
+This conversion is now reported because `message.value` is inferred as a string literal:
+
+```ts
+const message = { value: "text" as const };
+String(message.value);
+```

.changeset/use-exhaustive-switch-cases-as-const-property.md

@@ -0,0 +1,12 @@
+---
+"@biomejs/biome": patch
+---
+
+[`useExhaustiveSwitchCases`](https://biomejs.dev/linter/rules/use-exhaustive-switch-cases/) now checks switch statements over object literal properties initialized with `as const`.
+
+This switch is now reported because `status.kind` is inferred as the string literal `"ready"` but no case handles it:
+
+```ts
+const status = { kind: "ready" as const };
+switch (status.kind) {}
+```

.changeset/use-string-starts-ends-with-as-const-property.md

@@ -0,0 +1,12 @@
+---
+"@biomejs/biome": patch
+---
+
+[`useStringStartsEndsWith`](https://biomejs.dev/linter/rules/use-string-starts-ends-with/) now detects string index comparisons on object literal properties initialized with `as const`.
+
+This comparison is now reported because `message.value` is inferred as a string literal:
+
+```ts
+const message = { value: "hello" as const };
+message.value[0] === "h";
+```

crates/biome_js_analyze/src/lint/nursery/no_misleading_return_type.rs

@@ -551,6 +551,9 @@ fn is_only_property_literal_widening(annotation: &Type, returns: &[Type]) -> boo
             {
                 let mut index_signature_has_widening = false;
                 let all_inferred_covered = inferred_members.iter().all(|inferred_member| {
+                    if inferred_member.is_const_asserted() {
+                        return false;
+                    }
                     if let Some(inferred_type) = inferred.resolve(&inferred_member.ty) {
                         if types_match(&index_signature_value_type, &inferred_type) {
                             return true;
@@ -581,6 +584,9 @@ fn is_only_property_literal_widening(annotation: &Type, returns: &[Type]) -> boo
                 else {
                     return false;
                 };
+                if inferred_member.is_const_asserted() {
+                    return false;
+                }
                 match (
                     annotated.resolve(&annotated_member.ty),
                     inferred.resolve(&inferred_member.ty),
@@ -1489,15 +1495,9 @@ fn class_type_has_instance_shape(class: &Class) -> bool {
 
 /// Whether a type-info member contributes instance shape.
 fn type_member_affects_instance_shape(member: &biome_js_type_info::TypeMember) -> bool {
-    match &member.kind {
-        TypeMemberKind::Constructor
-        | TypeMemberKind::Getter(_)
-        | TypeMemberKind::NamedStatic(_)
-        | TypeMemberKind::IndexSignature(_) => false,
-        TypeMemberKind::CallSignature
-        | TypeMemberKind::Named(_)
-        | TypeMemberKind::NamedOptional(_) => true,
-    }
+    !member.is_static()
+        && !member.is_getter()
+        && !member.is_index_signature_with_ty(|_| true)
 }
 
 /// Compares non-union type pairs using a work stack. Compound types

crates/biome_js_analyze/tests/specs/nursery/noMisleadingReturnType/invalid.ts

@@ -136,3 +136,32 @@ function ternaryObjectBranch(b: boolean): object { return b ? {} : { a: 1 }; }
 class InheritedBase { y = 1; }
 class ClassWithInheritedMembers extends InheritedBase {}
 function inheritedClassInstance(): object { return new ClassWithInheritedMembers(); }
+
+function objectPropertyAsConst(): { a: string } {
+    return { a: "x" as const };
+}
+
+function parenthesizedObjectPropertyAsConst(): { a: string } {
+    return { a: ("x" as const) };
+}
+
+function objectPropertyNegativeNumberAsConst(): { a: number } {
+    return { a: -1 as const };
+}
+
+function objectPropertyTupleAsConst(): { a: [number, number] } {
+    return { a: [1, 2] as const };
+}
+
+function objectPropertyAsConstWithSibling(): { a: string; b: number } {
+    return { a: "x" as const, b: 1 };
+}
+
+function nestedObjectPropertyAsConst(): { outer: { a: string } } {
+    return { outer: { a: "x" as const } };
+}
+
+function objectWithConstPropertyFromIdentifier(): { a: string } {
+    const result = { a: "x" as const };
+    return result;
+}

crates/biome_js_analyze/tests/specs/nursery/noMisleadingReturnType/invalid.ts.snap

@@ -143,6 +143,35 @@ class InheritedBase { y = 1; }
 class ClassWithInheritedMembers extends InheritedBase {}
 function inheritedClassInstance(): object { return new ClassWithInheritedMembers(); }
 
+function objectPropertyAsConst(): { a: string } {
+    return { a: "x" as const };
+}
+
+function parenthesizedObjectPropertyAsConst(): { a: string } {
+    return { a: ("x" as const) };
+}
+
+function objectPropertyNegativeNumberAsConst(): { a: number } {
+    return { a: -1 as const };
+}
+
+function objectPropertyTupleAsConst(): { a: [number, number] } {
+    return { a: [1, 2] as const };
+}
+
+function objectPropertyAsConstWithSibling(): { a: string; b: number } {
+    return { a: "x" as const, b: 1 };
+}
+
+function nestedObjectPropertyAsConst(): { outer: { a: string } } {
+    return { outer: { a: "x" as const } };
+}
+
+function objectWithConstPropertyFromIdentifier(): { a: string } {
+    const result = { a: "x" as const };
+    return result;
+}
+
 ```
 
 # Diagnostics
@@ -1707,6 +1736,168 @@ invalid.ts:138:34 lint/nursery/noMisleadingReturnType ━━━━━━━━
   > 138 │ function inheritedClassInstance(): object { return new ClassWithInheritedMembers(); }
         │                                  ^^^^^^^^
     139 │ 
+    140 │ function objectPropertyAsConst(): { a: string } {
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:140:33 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    138 │ function inheritedClassInstance(): object { return new ClassWithInheritedMembers(); }
+    139 │ 
+  > 140 │ function objectPropertyAsConst(): { a: string } {
+        │                                 ^^^^^^^^^^^^^^^
+    141 │     return { a: "x" as const };
+    142 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:144:46 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    142 │ }
+    143 │ 
+  > 144 │ function parenthesizedObjectPropertyAsConst(): { a: string } {
+        │                                              ^^^^^^^^^^^^^^^
+    145 │     return { a: ("x" as const) };
+    146 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:148:47 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    146 │ }
+    147 │ 
+  > 148 │ function objectPropertyNegativeNumberAsConst(): { a: number } {
+        │                                               ^^^^^^^^^^^^^^^
+    149 │     return { a: -1 as const };
+    150 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:152:38 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    150 │ }
+    151 │ 
+  > 152 │ function objectPropertyTupleAsConst(): { a: [number, number] } {
+        │                                      ^^^^^^^^^^^^^^^^^^^^^^^^^
+    153 │     return { a: [1, 2] as const };
+    154 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:156:44 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    154 │ }
+    155 │ 
+  > 156 │ function objectPropertyAsConstWithSibling(): { a: string; b: number } {
+        │                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
+    157 │     return { a: "x" as const, b: 1 };
+    158 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:160:39 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    158 │ }
+    159 │ 
+  > 160 │ function nestedObjectPropertyAsConst(): { outer: { a: string } } {
+        │                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
+    161 │     return { outer: { a: "x" as const } };
+    162 │ }
+  
+  i A wider return type hides the precise types that callers could rely on.
+  
+  i Narrow the return type to match what the function actually returns.
+  
+  i This rule is still being actively worked on, so it may be missing features or have rough edges. Visit https://github.com/biomejs/biome/issues/9810 for more information or to report possible bugs.
+  
+  i This rule belongs to the nursery group, which means it is not yet stable and may change in the future. Visit https://biomejs.dev/linter/#nursery for more information.
+  
+
+```
+
+```
+invalid.ts:164:49 lint/nursery/noMisleadingReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  i The return type annotation is wider than what the function actually returns.
+  
+    162 │ }
+    163 │ 
+  > 164 │ function objectWithConstPropertyFromIdentifier(): { a: string } {
+        │                                                 ^^^^^^^^^^^^^^^
+    165 │     const result = { a: "x" as const };
+    166 │     return result;
   
   i A wider return type hides the precise types that callers could rely on.
   

crates/biome_js_analyze/tests/specs/nursery/noMisleadingReturnType/valid.ts

@@ -61,6 +61,14 @@ function objectNoConst(): { a: string; b: string } {
     return { a: "x", b: "y" };
 }
 
+function propertyLiteralWithoutAsConst(): { a: string } {
+    return { a: "x" };
+}
+
+function propertyAsConstExact(): { a: "x" } {
+    return { a: "x" as const };
+}
+
 function asConstMatch(): "hello" { return "hello" as const; }
 
 function bareReturn(): void { return; }

crates/biome_js_analyze/tests/specs/nursery/noMisleadingReturnType/valid.ts.snap

@@ -67,6 +67,14 @@ function objectNoConst(): { a: string; b: string } {
     return { a: "x", b: "y" };
 }
 
+function propertyLiteralWithoutAsConst(): { a: string } {
+    return { a: "x" };
+}
+
+function propertyAsConstExact(): { a: "x" } {
+    return { a: "x" as const };
+}
+
 function asConstMatch(): "hello" { return "hello" as const; }
 
 function bareReturn(): void { return; }

crates/biome_js_analyze/tests/specs/nursery/noUselessTypeConversion/invalid.ts

@@ -70,3 +70,6 @@ function reqStr(x: Required<{s?: string}>) { return String(x.s); }
 function reqNum(x: Required<{n?: number}>) { return Number(x.n); }
 function reqBig(x: Required<{b?: bigint}>) { return BigInt(x.b); }
 function roStr(x: Readonly<{s: string}>) { return String(x.s); }
+
+const wrappedStringContainer = { value: "wrapped" as const };
+String(wrappedStringContainer.value);