Refactor type resolution logic in getTypeOfSymbol for improved readability and maintainability

Author: Bashamega

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));