call := callExpr.AsCallExpression()
			if call.QuestionDotToken == nil && !hasOptionalChain(call.Expression) {
				if callType := getResolvedType(callExpr); callType != nil {
					return callType
				}
			}

			funcType := getResolvedType(call.Expression)
			if funcType == nil {
				return nil
			}

			nonNullishFunc := removeNullishFromType(funcType)
			if nonNullishFunc == nil {
				return nil
			}

			// If it's a union type of functions, check each part's return type
			// e.g., (() => undefined) | (() => number) should check if any returns nullish
			if utils.IsUnionType(nonNullishFunc) {
				// For union of functions, check if any function returns a nullish type
				// If so, the optional chaining result can be nullish
				parts := nonNullishFunc.Types()
				for _, part := range parts {
					sigs := ctx.TypeChecker.GetCallSignatures(part)
					if len(sigs) > 0 {
						retType := ctx.TypeChecker.GetReturnTypeOfSignature(sigs[0])
						if retType != nil && isNullishType(retType) {
							// At least one function returns nullish, so use full expression type
							// which includes all possible return types
							return ctx.TypeChecker.GetTypeAtLocation(callExpr)
						}
					}
				}
				// No function returns nullish, get first signature's return type
				signatures := ctx.TypeChecker.GetCallSignatures(nonNullishFunc)
				if len(signatures) > 0 {
					return ctx.TypeChecker.GetReturnTypeOfSignature(signatures[0])
				}
				return nil
			}

			signatures := ctx.TypeChecker.GetCallSignatures(nonNullishFunc)
			if len(signatures) == 0 {
				return nil
			}

			return ctx.TypeChecker.GetReturnTypeOfSignature(signatures[0])