From 57390f8ba7c3471785515c1889028c4e9e3a7352 Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:26:07 +0200 Subject: [PATCH 1/7] Refactor type resolution logic in getTypeOfSymbol for improved readability and maintainability --- src/compiler/checker.ts | 53 +++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 28 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index caab75c99fa8a..961696a06a74b 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12282,36 +12282,33 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeOfSymbol(symbol: Symbol): Type { + // Retrieve the check flags for the given symbol const checkFlags = getCheckFlags(symbol); - if (checkFlags & CheckFlags.DeferredType) { - return getTypeOfSymbolWithDeferredType(symbol); - } - if (checkFlags & CheckFlags.Instantiated) { - return getTypeOfInstantiatedSymbol(symbol); - } - if (checkFlags & CheckFlags.Mapped) { - return getTypeOfMappedSymbol(symbol as MappedSymbol); - } - if (checkFlags & CheckFlags.ReverseMapped) { - return getTypeOfReverseMappedSymbol(symbol as ReverseMappedSymbol); - } - if (symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property)) { - return getTypeOfVariableOrParameterOrProperty(symbol); - } - if (symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) { - return getTypeOfFuncClassEnumModule(symbol); - } - if (symbol.flags & SymbolFlags.EnumMember) { - return getTypeOfEnumMember(symbol); - } - if (symbol.flags & SymbolFlags.Accessor) { - return getTypeOfAccessors(symbol); - } - if (symbol.flags & SymbolFlags.Alias) { - return getTypeOfAlias(symbol); - } + + // Define a mapping of flag checks to their respective type resolver functions + const typeResolvers: [number, (sym: Symbol) => Type][] = [ + // Check for deferred type symbols + [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], // Check for instantiated symbols + [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], // Check for mapped symbols (cast to MappedSymbol) + [CheckFlags.Mapped, (sym) => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) + [CheckFlags.ReverseMapped, (sym) => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties + [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], // Check for functions, methods, classes, enums, and value modules + [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], // Check for enum members + [SymbolFlags.EnumMember, getTypeOfEnumMember], // Check for accessor symbols + [SymbolFlags.Accessor, getTypeOfAccessors], // Check for alias symbols + [SymbolFlags.Alias, getTypeOfAlias], + ]; + + // Iterate through the mapping and return the corresponding type if a flag matches + for (const [flag, resolver] of typeResolvers) { + if ((checkFlags & flag) || (symbol.flags & flag)) { + return resolver(symbol); + } + } + + // Return the error type if no conditions match return errorType; - } + } function getNonMissingTypeOfSymbol(symbol: Symbol) { return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & SymbolFlags.Optional)); From 9f70c9204c879b846269576d92c3dfb2b077a0a9 Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:34:01 +0200 Subject: [PATCH 2/7] chore: format files --- src/compiler/checker.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 961696a06a74b..02845e9e48934 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12284,31 +12284,31 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getTypeOfSymbol(symbol: Symbol): Type { // Retrieve the check flags for the given symbol const checkFlags = getCheckFlags(symbol); - + // Define a mapping of flag checks to their respective type resolver functions const typeResolvers: [number, (sym: Symbol) => Type][] = [ // Check for deferred type symbols [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], // Check for instantiated symbols [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], // Check for mapped symbols (cast to MappedSymbol) - [CheckFlags.Mapped, (sym) => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) - [CheckFlags.ReverseMapped, (sym) => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties + [CheckFlags.Mapped, sym => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) + [CheckFlags.ReverseMapped, sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], // Check for functions, methods, classes, enums, and value modules [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], // Check for enum members [SymbolFlags.EnumMember, getTypeOfEnumMember], // Check for accessor symbols [SymbolFlags.Accessor, getTypeOfAccessors], // Check for alias symbols [SymbolFlags.Alias, getTypeOfAlias], ]; - + // Iterate through the mapping and return the corresponding type if a flag matches for (const [flag, resolver] of typeResolvers) { if ((checkFlags & flag) || (symbol.flags & flag)) { return resolver(symbol); } } - + // Return the error type if no conditions match return errorType; - } + } function getNonMissingTypeOfSymbol(symbol: Symbol) { return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & SymbolFlags.Optional)); From 5abd5b31745b4a36eafc1b1245ff4f55e9195a18 Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:40:20 +0200 Subject: [PATCH 3/7] Refactor type resolution logic in getTypeOfSymbol for improved clarity and performance --- src/compiler/checker.ts | 33 ++++++++++++--------------------- 1 file changed, 12 insertions(+), 21 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 02845e9e48934..b7d6db140f1c0 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12282,32 +12282,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeOfSymbol(symbol: Symbol): Type { - // Retrieve the check flags for the given symbol const checkFlags = getCheckFlags(symbol); - // Define a mapping of flag checks to their respective type resolver functions - const typeResolvers: [number, (sym: Symbol) => Type][] = [ - // Check for deferred type symbols - [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], // Check for instantiated symbols - [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], // Check for mapped symbols (cast to MappedSymbol) - [CheckFlags.Mapped, sym => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) - [CheckFlags.ReverseMapped, sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties - [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], // Check for functions, methods, classes, enums, and value modules - [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], // Check for enum members - [SymbolFlags.EnumMember, getTypeOfEnumMember], // Check for accessor symbols - [SymbolFlags.Accessor, getTypeOfAccessors], // Check for alias symbols - [SymbolFlags.Alias, getTypeOfAlias], + const typeResolvers: { flag: number; resolver: (sym: Symbol) => Type; }[] = [ + { flag: CheckFlags.DeferredType, resolver: getTypeOfSymbolWithDeferredType }, + { flag: CheckFlags.Instantiated, resolver: getTypeOfInstantiatedSymbol }, + { flag: CheckFlags.Mapped, resolver: sym => getTypeOfMappedSymbol(sym as MappedSymbol) }, + { flag: CheckFlags.ReverseMapped, resolver: sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol) }, + { flag: SymbolFlags.Variable | SymbolFlags.Property, resolver: getTypeOfVariableOrParameterOrProperty }, + { flag: SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, resolver: getTypeOfFuncClassEnumModule }, + { flag: SymbolFlags.EnumMember, resolver: getTypeOfEnumMember }, + { flag: SymbolFlags.Accessor, resolver: getTypeOfAccessors }, + { flag: SymbolFlags.Alias, resolver: getTypeOfAlias }, ]; - // Iterate through the mapping and return the corresponding type if a flag matches - for (const [flag, resolver] of typeResolvers) { - if ((checkFlags & flag) || (symbol.flags & flag)) { - return resolver(symbol); - } - } + const matchedResolver = typeResolvers.find(({ flag }) => (checkFlags & flag) !== 0 || (symbol.flags & flag) !== 0); - // Return the error type if no conditions match - return errorType; + return matchedResolver ? matchedResolver.resolver(symbol) : errorType; } function getNonMissingTypeOfSymbol(symbol: Symbol) { From f9fb152f438c0241aeab011e9c467e42cb1dc3c6 Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:42:47 +0200 Subject: [PATCH 4/7] Refactor type resolution logic in createTypeChecker for improved accuracy --- src/compiler/checker.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index b7d6db140f1c0..21e92c02f7551 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12296,7 +12296,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { { flag: SymbolFlags.Alias, resolver: getTypeOfAlias }, ]; - const matchedResolver = typeResolvers.find(({ flag }) => (checkFlags & flag) !== 0 || (symbol.flags & flag) !== 0); + const matchedResolver = typeResolvers.find(({ flag }) => (checkFlags & flag) !== 0); return matchedResolver ? matchedResolver.resolver(symbol) : errorType; } From 52b209c5d57bcf209fa130a5564ea175d4acc408 Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:50:34 +0200 Subject: [PATCH 5/7] - --- src/compiler/checker.ts | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 21e92c02f7551..32040c1e9e1e6 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12282,23 +12282,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeOfSymbol(symbol: Symbol): Type { + // Retrieve the check flags for the given symbol const checkFlags = getCheckFlags(symbol); - const typeResolvers: { flag: number; resolver: (sym: Symbol) => Type; }[] = [ - { flag: CheckFlags.DeferredType, resolver: getTypeOfSymbolWithDeferredType }, - { flag: CheckFlags.Instantiated, resolver: getTypeOfInstantiatedSymbol }, - { flag: CheckFlags.Mapped, resolver: sym => getTypeOfMappedSymbol(sym as MappedSymbol) }, - { flag: CheckFlags.ReverseMapped, resolver: sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol) }, - { flag: SymbolFlags.Variable | SymbolFlags.Property, resolver: getTypeOfVariableOrParameterOrProperty }, - { flag: SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, resolver: getTypeOfFuncClassEnumModule }, - { flag: SymbolFlags.EnumMember, resolver: getTypeOfEnumMember }, - { flag: SymbolFlags.Accessor, resolver: getTypeOfAccessors }, - { flag: SymbolFlags.Alias, resolver: getTypeOfAlias }, + // Define a mapping of flag checks to their respective type resolver functions + const typeResolvers: [number, (sym: Symbol) => Type][] = [ + // Check for deferred type symbols + [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], // Check for instantiated symbols + [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], // Check for mapped symbols (cast to MappedSymbol) + [CheckFlags.Mapped, sym => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) + [CheckFlags.ReverseMapped, sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties + [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], // Check for functions, methods, classes, enums, and value modules + [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], // Check for enum members + [SymbolFlags.EnumMember, getTypeOfEnumMember], // Check for accessor symbols + [SymbolFlags.Accessor, getTypeOfAccessors], // Check for alias symbols + [SymbolFlags.Alias, getTypeOfAlias], ]; - const matchedResolver = typeResolvers.find(({ flag }) => (checkFlags & flag) !== 0); + // Iterate through the mapping and return the corresponding type if a flag matches + for (const [flag, resolver] of typeResolvers) { + if ((checkFlags & flag)) { + return resolver(symbol); + } + } - return matchedResolver ? matchedResolver.resolver(symbol) : errorType; + // Return the error type if no conditions match + return errorType; } function getNonMissingTypeOfSymbol(symbol: Symbol) { From 41b0a9f6e8674b7943fd6588caca1a5c9777bcde Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 07:58:32 +0200 Subject: [PATCH 6/7] - --- src/compiler/checker.ts | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 32040c1e9e1e6..9cb7fde0f1b4e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12282,31 +12282,31 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function getTypeOfSymbol(symbol: Symbol): Type { - // Retrieve the check flags for the given symbol const checkFlags = getCheckFlags(symbol); - // Define a mapping of flag checks to their respective type resolver functions - const typeResolvers: [number, (sym: Symbol) => Type][] = [ - // Check for deferred type symbols - [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], // Check for instantiated symbols - [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], // Check for mapped symbols (cast to MappedSymbol) - [CheckFlags.Mapped, sym => getTypeOfMappedSymbol(sym as MappedSymbol)], // Check for reverse-mapped symbols (cast to ReverseMappedSymbol) - [CheckFlags.ReverseMapped, sym => getTypeOfReverseMappedSymbol(sym as ReverseMappedSymbol)], // Check for variables and properties - [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], // Check for functions, methods, classes, enums, and value modules - [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], // Check for enum members - [SymbolFlags.EnumMember, getTypeOfEnumMember], // Check for accessor symbols - [SymbolFlags.Accessor, getTypeOfAccessors], // Check for alias symbols + const checkFlagMap = new Map([ + [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], + [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], + [CheckFlags.Mapped, (s: Symbol) => getTypeOfMappedSymbol(s as MappedSymbol)], + [CheckFlags.ReverseMapped, (s: Symbol) => getTypeOfReverseMappedSymbol(s as ReverseMappedSymbol)], + ]); + + for (const [flag, fn] of checkFlagMap) { + if (checkFlags & flag) return fn(symbol); + } + + const symbolFlagMap = new Map([ + [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], + [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], + [SymbolFlags.EnumMember, getTypeOfEnumMember], + [SymbolFlags.Accessor, getTypeOfAccessors], [SymbolFlags.Alias, getTypeOfAlias], - ]; + ]); - // Iterate through the mapping and return the corresponding type if a flag matches - for (const [flag, resolver] of typeResolvers) { - if ((checkFlags & flag)) { - return resolver(symbol); - } + for (const [flag, fn] of symbolFlagMap) { + if (symbol.flags & flag) return fn(symbol); } - // Return the error type if no conditions match return errorType; } From 226d17a647e74e6e16987db21974ef327c96ea4d Mon Sep 17 00:00:00 2001 From: Bashamega Date: Wed, 12 Mar 2025 08:11:04 +0200 Subject: [PATCH 7/7] - --- src/compiler/checker.ts | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9cb7fde0f1b4e..2be9f5251a03e 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -12284,29 +12284,30 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function getTypeOfSymbol(symbol: Symbol): Type { const checkFlags = getCheckFlags(symbol); - const checkFlagMap = new Map([ + // Prioritize check flags + const checkFlagChecks: [CheckFlags, (s: Symbol) => Type][] = [ [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType], [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol], - [CheckFlags.Mapped, (s: Symbol) => getTypeOfMappedSymbol(s as MappedSymbol)], - [CheckFlags.ReverseMapped, (s: Symbol) => getTypeOfReverseMappedSymbol(s as ReverseMappedSymbol)], - ]); + [CheckFlags.Mapped, s => getTypeOfMappedSymbol(s as MappedSymbol)], + [CheckFlags.ReverseMapped, s => getTypeOfReverseMappedSymbol(s as ReverseMappedSymbol)], + ]; - for (const [flag, fn] of checkFlagMap) { + for (const [flag, fn] of checkFlagChecks) { if (checkFlags & flag) return fn(symbol); } - const symbolFlagMap = new Map([ + // Handle symbol flags + const symbolChecks: [SymbolFlags, (s: Symbol) => Type][] = [ [SymbolFlags.Variable | SymbolFlags.Property, getTypeOfVariableOrParameterOrProperty], [SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule, getTypeOfFuncClassEnumModule], [SymbolFlags.EnumMember, getTypeOfEnumMember], [SymbolFlags.Accessor, getTypeOfAccessors], [SymbolFlags.Alias, getTypeOfAlias], - ]); + ]; - for (const [flag, fn] of symbolFlagMap) { - if (symbol.flags & flag) return fn(symbol); + for (const [flag, fn] of symbolChecks) { + if ((symbol.flags & flag) !== 0) return fn(symbol); } - return errorType; }