Refactor type resolution logic in getTypeOfSymbol for improved readability and maintainability

src/compiler/checker.ts

@@ -12283,32 +12283,30 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
 
     function getTypeOfSymbol(symbol: Symbol): Type {
         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);
+
+        // Prioritize check flags
+        const checkFlagChecks: [CheckFlags, (s: Symbol) => Type][] = [
+            [CheckFlags.DeferredType, getTypeOfSymbolWithDeferredType],
+            [CheckFlags.Instantiated, getTypeOfInstantiatedSymbol],
+            [CheckFlags.Mapped, s => getTypeOfMappedSymbol(s as MappedSymbol)],
+            [CheckFlags.ReverseMapped, s => getTypeOfReverseMappedSymbol(s as ReverseMappedSymbol)],
+        ];
+
+        for (const [flag, fn] of checkFlagChecks) {
+            if (checkFlags & flag) return fn(symbol);
+        }
+
+        // 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 symbolChecks) {
+            if ((symbol.flags & flag) !== 0) return fn(symbol);
         }
         return errorType;
     }