Refactoring

Author: michaldudak

src/parsers/propertyParser.ts

@@ -29,15 +29,16 @@ export function parseProperty(
 
 		let isOptional = false;
 
-		// Typechecker only gives the type "any" if it's present in a union
-		// This means the type of "a" in {a?:any} isn't "any | undefined"
-		// So instead we check for the questionmark to detect optional types
 		const parsedType = resolveType(
 			type,
 			context,
 			isTypeParameterLike(type) ? undefined : propertySignature?.type,
 			skipResolvingComplexTypes,
 		);
+
+		// Typechecker only gives the type "any" if it's present in a union
+		// This means the type of "a" in {a?:any} isn't "any | undefined"
+		// So instead we check for the questionmark to detect optional types
 		if ((type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown) && propertySignature) {
 			isOptional = Boolean(propertySignature.questionToken);
 		} else {

src/parsers/typeResolver.ts

@@ -37,6 +37,32 @@ export function resolveType(
 		typeStack.push(typeId);
 	}
 
+	function areEquivalent(typeNodeName: ts.EntityName, type: ts.Type): boolean | undefined {
+		if (ts.isIdentifier(typeNodeName)) {
+			const typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName);
+			if (!typeSymbolCandidate) {
+				return undefined;
+			}
+
+			return (
+				typeNodeName.text === type.aliasSymbol?.name &&
+				getTypeSymbolNamespaces(typeSymbolCandidate).join('.') === getTypeNamespaces(type).join('.')
+			);
+		} else if (ts.isQualifiedName(typeNodeName)) {
+			const typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName.right);
+			if (!typeSymbolCandidate) {
+				return undefined;
+			}
+
+			return (
+				typeNodeName.right.text === type.aliasSymbol?.name &&
+				getTypeSymbolNamespaces(typeSymbolCandidate).join('.') === getTypeNamespaces(type).join('.')
+			);
+		}
+
+		return undefined;
+	}
+
 	// The following code handles cases where the type is a simple alias of another type (type Alias = SomeType).
 	// TypeScript resolves the alias automatically, but we want to preserve the original type symbol if it exists.
 	//
@@ -45,29 +71,19 @@ export function resolveType(
 	let typeSymbol: ts.Symbol | undefined;
 	if (typeNode && ts.isTypeReferenceNode(typeNode)) {
 		const typeNodeName = (typeNode as ts.TypeReferenceNode).typeName;
+		let typeSymbolCandidate: ts.Symbol | undefined;
 		if (ts.isIdentifier(typeNodeName)) {
-			const typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName);
-
-			if (
-				typeSymbolCandidate &&
-				(typeNodeName.text !== type.aliasSymbol?.name ||
-					getTypeSymbolNamespaces(typeSymbolCandidate).join('.') !==
-						getTypeNamespaces(type).join('.')) &&
-				!(typeSymbolCandidate.flags & ts.SymbolFlags.TypeParameter)
-			) {
-				typeSymbol = typeSymbolCandidate;
-			}
+			typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName);
 		} else if (ts.isQualifiedName(typeNodeName)) {
-			const typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName.right);
-			if (
-				typeSymbolCandidate &&
-				(typeNodeName.right.text !== type.aliasSymbol?.name ||
-					getTypeSymbolNamespaces(typeSymbolCandidate).join('.') !==
-						getTypeNamespaces(type).join('.')) &&
-				!(typeSymbolCandidate.flags & ts.SymbolFlags.TypeParameter)
-			) {
-				typeSymbol = typeSymbolCandidate;
-			}
+			typeSymbolCandidate = checker.getSymbolAtLocation(typeNodeName.right);
+		}
+
+		if (
+			typeSymbolCandidate &&
+			!areEquivalent(typeNodeName, type) &&
+			!(typeSymbolCandidate.flags & ts.SymbolFlags.TypeParameter)
+		) {
+			typeSymbol = typeSymbolCandidate;
 		}
 	}