Refactor PropertyAssignment node reuse logic based on code review

Co-authored-by: RyanCavanaugh <[email protected]>

Author: Copilot

internal/checker/nodebuilderimpl.go

@@ -1644,6 +1644,21 @@ func getJSDocTypeAssertionType(node *ast.Node) *ast.TypeNode {
 	return nil
 }
 
+// getTypeForDeclaration resolves the type for a declaration, considering various special cases.
+func (b *nodeBuilderImpl) getTypeForDeclaration(symbol *ast.Symbol, declaration *ast.Declaration) *Type {
+	t := b.ctx.enclosingSymbolTypes[ast.GetSymbolId(symbol)]
+	if t == nil {
+		if symbol.Flags&ast.SymbolFlagsAccessor != 0 && declaration != nil && declaration.Kind == ast.KindSetAccessor {
+			t = b.ch.instantiateType(b.ch.getWriteTypeOfSymbol(symbol), b.ctx.mapper)
+		} else if symbol != nil && (symbol.Flags&(ast.SymbolFlagsTypeLiteral|ast.SymbolFlagsSignature) == 0) {
+			t = b.ch.instantiateType(b.ch.getWidenedLiteralType(b.ch.getTypeOfSymbol(symbol)), b.ctx.mapper)
+		} else {
+			t = b.ch.errorType
+		}
+	}
+	return t
+}
+
 func (b *nodeBuilderImpl) serializeTypeForExpression(expr *ast.Node) *ast.Node {
 	// !!! TODO: shim, add node reuse
 	t := b.ch.instantiateType(b.ch.getWidenedType(b.ch.getRegularTypeOfExpression(expr)), b.ctx.mapper)
@@ -1998,28 +2013,22 @@ func (b *nodeBuilderImpl) serializeTypeForDeclaration(declaration *ast.Declarati
 	// Check for PropertyAssignment with type assertion that can be reused (PR #60576)
 	if declaration != nil && declaration.Kind == ast.KindPropertyAssignment {
 		initializer := declaration.AsPropertyAssignment().Initializer
+		initializerKind := initializer.Kind
 		var assertionNode *ast.TypeNode
 
 		// Check if initializer is a JSDoc type assertion
 		if ast.IsJSDocTypeAssertion(initializer) {
 			assertionNode = getJSDocTypeAssertionType(initializer)
-		} else if initializer.Kind == ast.KindAsExpression || initializer.Kind == ast.KindTypeAssertionExpression {
+		} else if initializerKind == ast.KindAsExpression || initializerKind == ast.KindTypeAssertionExpression {
 			// Extract the type node from AsExpression or TypeAssertion
-			if initializer.Kind == ast.KindAsExpression {
-				assertionNode = initializer.AsAsExpression().Type
-			} else {
-				assertionNode = initializer.AsTypeAssertion().Type
-			}
+			assertionNode = getAssertedTypeNode(initializer)
 		}
 
 		// If we have an assertion node, check if we can reuse it
 		if assertionNode != nil && !isConstTypeReference(assertionNode) {
 			// Try to reuse the existing type node if it's equivalent
 			if t == nil {
-				t = b.ctx.enclosingSymbolTypes[ast.GetSymbolId(symbol)]
-				if t == nil && symbol != nil && (symbol.Flags&(ast.SymbolFlagsTypeLiteral|ast.SymbolFlagsSignature) == 0) {
-					t = b.ch.instantiateType(b.ch.getWidenedLiteralType(b.ch.getTypeOfSymbol(symbol)), b.ctx.mapper)
-				}
+				t = b.getTypeForDeclaration(symbol, declaration)
 			}
 
 			if t != nil {
@@ -2032,16 +2041,7 @@ func (b *nodeBuilderImpl) serializeTypeForDeclaration(declaration *ast.Declarati
 	}
 
 	if t == nil {
-		t = b.ctx.enclosingSymbolTypes[ast.GetSymbolId(symbol)]
-		if t == nil {
-			if symbol.Flags&ast.SymbolFlagsAccessor != 0 && declaration.Kind == ast.KindSetAccessor {
-				t = b.ch.instantiateType(b.ch.getWriteTypeOfSymbol(symbol), b.ctx.mapper)
-			} else if symbol != nil && (symbol.Flags&(ast.SymbolFlagsTypeLiteral|ast.SymbolFlagsSignature) == 0) {
-				t = b.ch.instantiateType(b.ch.getWidenedLiteralType(b.ch.getTypeOfSymbol(symbol)), b.ctx.mapper)
-			} else {
-				t = b.ch.errorType
-			}
-		}
+		t = b.getTypeForDeclaration(symbol, declaration)
 	}
 
 	// !!! TODO: JSDoc, getEmitResolver call is unfortunate layering for the helper - hoist it into checker