fix(useAwaitThenable): treat unresolved call expressions as uninferred

.changeset/quiet-owls-listen.md

@@ -0,0 +1,6 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [#8476](https://github.com/biomejs/biome/issues/8476).
+[useAwaitThenable](https://biomejs.dev/linter/rules/use-await-thenable/) no longer reports false positives for `await` on call expressions whose return type cannot be resolved (e.g., cross-module function calls to Node.js builtins or npm packages).

crates/biome_js_analyze/tests/specs/nursery/useAwaitThenable/valid.js

@@ -4,3 +4,12 @@ await Promise.resolve('value');
 
 const createValue = async () => 'value';
 await createValue();
+
+// Cross-module calls whose return type can't be resolved should not
+// produce false positives. Biome doesn't parse .d.ts from node_modules,
+// so these remain as unresolved TypeofExpression types.
+import fs from "node:fs/promises";
+await fs.readFile("test.txt", "utf-8");
+
+import { someFunction } from "some-external-package";
+await someFunction();

crates/biome_js_analyze/tests/specs/nursery/useAwaitThenable/valid.js.snap

@@ -11,4 +11,13 @@ await Promise.resolve('value');
 const createValue = async () => 'value';
 await createValue();
 
+// Cross-module calls whose return type can't be resolved should not
+// produce false positives. Biome doesn't parse .d.ts from node_modules,
+// so these remain as unresolved TypeofExpression types.
+import fs from "node:fs/promises";
+await fs.readFile("test.txt", "utf-8");
+
+import { someFunction } from "some-external-package";
+await someFunction();
+
 ```

crates/biome_js_type_info/src/type_data.rs

@@ -299,12 +299,16 @@ impl TypeData {
 
     /// Returns whether the given type has been inferred.
     ///
-    /// A type is considered inferred if it is anything except `Self::Unknown`
-    /// or an unknown reference, including an unexplicit `unknown` keyword.
+    /// A type is considered inferred if it is anything except `Self::Unknown`,
+    /// an unknown reference, or an unresolved typeof expression. Unresolved
+    /// typeof expressions represent type computations (e.g., return types of
+    /// cross-module function calls) that could not be flattened, so their
+    /// actual type is unknown.
     pub fn is_inferred(&self) -> bool {
         match self {
             Self::Reference(TypeReference::Resolved(resolved)) => *resolved != GLOBAL_UNKNOWN_ID,
             Self::Unknown => false,
+            Self::TypeofExpression(_) => false,
             _ => true,
         }
     }