🐛 False positive in rule noUndeclaredVariables

[AndreiTS]

Environment information

sorry cant provide it (it's too big)

What happened?

Using the hook specified in https://docs.pmnd.rs/zustand/guides/auto-generating-selectors apparently raises a false positive in the rule noUndeclaredVariables: playground

Expected result

I think in this case there should be no warning

Code of Conduct

• I agree to follow Biome's Code of Conduct

[denbezrukov]

The issue is the interaction between infer T that creates the binding T and the function signature TsFunctionType that creates its own scope.

biome/crates/biome_js_semantic/src/events.rs

Lines 307 to 314 in 106538b

	| TS_FUNCTION_TYPE
	| TS_DECLARE_FUNCTION_DECLARATION => {
	self.push_scope(
	node.text_range(),
	ScopeHoisting::DontHoistDeclarationsToParent,
	false,
	);
	}

Let start with: type A<U> = U extends {a: infer T} ? T : never.

When we don't have a TsFunctionType, the T binding belongs to TsTypeAliasDeclaration.
I assume that if we have infer T inside the TsFunctionType scope and it's inside TsConditionalType, it should propagate to the nearest TsTypeAliasDeclaration/TsConditionalType. TsConditionalType doesn't create a scope now.

Do I understand correctly that infer can be used only inside extends?

[strager]

Do I understand correctly that infer can be used only inside extends?

That is the only context in which I've seen infer, yes.

---

Note that infer can get wacky as it's not lexically scoped. For example, see this quick-lint-js test case:

MyType extends (OtherType extends infer T ? infer U : InnerFalse) ? OuterTrue : OuterFalse
//                         T is usable here ^^^^^^^
//                                                 U is usable here ^^^^^^^^^

[denbezrukov]

@strager Thank you!
Oh, it seems that we handle this case incorrectly.
Playground

Could you please explain how quick-lint-js creates scopes for TS?

[strager]

Could you please explain how quick-lint-js creates scopes for TS?

Assuming we are parsing A extends B ? T : F:

Global variable: typescript_infer_declaration_buffer: Vec<Vec<Ident>>

Overall type parsing algorithm (relevant bits only) (this should be obvious):

1. If we see infer:
   1. Skip infer
   2. Expect an identifier
   3. Stop
2. Parse type A
3. If we see extends:
   1. Skip extends
   2. Parse type B
   3. Expect ?
   4. Parse type T
   5. Expect :
   6. Parse type F

When we parse B:

1. Push a new Vec<Ident> onto typescript_infer_declaration_buffer
2. Parse type B
3. Pop from typescript_infer_declaration_buffer into a local variable infers

When we see infer X (in any type, not just inside an extends)

1. If typescript_infer_declaration_buffer is empty, report Diag_TypeScript_Infer_Outside_Conditional_Type
2. Otherwise, push X onto the top of typescript_infer_declaration_buffer

When we parse T:

1. Enter a scope
2. Declare each variable of infers
3. Parse type T
4. Exit a scope

[quantizor]

Another example of code using infer that triggers a false positive:

type ActionPreferenceNames<Name extends PreferenceName, Actions> = {
    [ActionName in keyof Actions]?: Actions[ActionName] extends (value: infer U) => void
      ? KeysWithValuesOfType<Required<GetPreferenceValue<Name>>, Exclude<U, undefined>>
      : never;
  };

// The U variable is undeclared biome[lint/correctness/noUndeclaredVariables]