Swift 5编译错误：无法在合理时间内检查表达式类型求助

问题背景 #

更新Xcode及Swift版本后，克隆的GitHub仓库无法编译，报错：

The compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions

错误出现在两处包含representedElements + cells.flatMap { group -> [UICollectionViewLayoutAttributes] in的return语句，因嵌套闭包叠加复杂表达式导致编译器类型检查超时，仓库已无人维护，需手动简化代码。

解决方案 #

核心思路是把嵌套闭包拆分为独立函数，同时将复杂的数值计算拆解为多个子步骤，降低编译器类型检查的复杂度。

步骤1：提取水平方向重排逻辑为独立函数 #

在当前类中添加以下函数：

private func repositionHorizontalGroup(_ group: [UICollectionViewLayoutAttributes]) -> [UICollectionViewLayoutAttributes] {
    guard let section = group.first?.indexPath.section else {
        return group
    }
    
    // 拆分复杂计算为子步骤
    let sectionInset = evaluatedSectionInsetForSection(at: section)
    let interitemSpacing = evaluatedMinimumInteritemSpacingForSection(at: section)
    
    // 计算所有元素总宽度
    let totalItemWidth = group.reduce(0) { sum, attributes in
        sum + attributes.frame.size.width
    }
    // 计算总间距
    let totalSpacing = CGFloat(group.count - 1) * interitemSpacing
    // 计算初始origin值
    let availableWidth = collectionView.bounds.width + sectionInset.left - sectionInset.right
    var originX = (availableWidth - totalItemWidth - totalSpacing) / 2
    
    // 重排元素
    return group.map { attributes in
        var mutableAttributes = attributes
        mutableAttributes.frame.origin.x = originX
        originX += mutableAttributes.frame.size.width + interitemSpacing
        return mutableAttributes
    }
}

步骤2：提取垂直方向重排逻辑为独立函数 #

继续添加以下函数：

private func repositionVerticalGroup(_ group: [UICollectionViewLayoutAttributes]) -> [UICollectionViewLayoutAttributes] {
    guard let section = group.first?.indexPath.section else {
        return group
    }
    
    // 拆分复杂计算为子步骤
    let sectionInset = evaluatedSectionInsetForSection(at: section)
    let interitemSpacing = evaluatedMinimumInteritemSpacingForSection(at: section)
    
    // 计算所有元素总高度
    let totalItemHeight = group.reduce(0) { sum, attributes in
        sum + attributes.frame.size.height
    }
    // 计算总间距
    let totalSpacing = CGFloat(group.count - 1) * interitemSpacing
    // 计算初始origin值
    let availableHeight = collectionView.bounds.height + sectionInset.top - sectionInset.bottom
    var originY = (availableHeight - totalItemHeight - totalSpacing) / 2
    
    // 重排元素
    return group.map { attributes in
        var mutableAttributes = attributes
        mutableAttributes.frame.origin.y = originY
        originY += mutableAttributes.frame.size.height + interitemSpacing
        return mutableAttributes
    }
}

步骤3：替换原代码中的复杂闭包 #

将原代码中两处报错的return语句替换为调用上述函数的形式：

替换第一处（水平方向）：

原代码：

return representedElements + cells.flatMap { group -> [UICollectionViewLayoutAttributes] in
    // ... 原复杂闭包内容
}

替换为：

return representedElements + cells.flatMap(repositionHorizontalGroup)

替换第二处（垂直方向）：

原代码：

return representedElements + cells.flatMap { group -> [UICollectionViewLayoutAttributes] in
    // ... 原复杂闭包内容
}

替换为：

return representedElements + cells.flatMap(repositionVerticalGroup)

修改后的完整代码片段 #

// （此处保留原代码中if分支的其他逻辑）
} else {
    for layoutAttributes in layoutAttributesForElements {
        guard layoutAttributes.representedElementKind == nil else {
            representedElements.append(layoutAttributes)
            continue
        }
        // copying is required to avoid "UICollectionViewFlowLayout cache mismatched frame"
        let currentItemAttributes = layoutAttributes.copy() as! UICollectionViewLayoutAttributes
        // if the current frame, once stretched to the full column doesn't intersect the previous frame then they are on different columns
        if previousFrame != nil && !currentItemAttributes.frame.intersects(CGRect(x: previousFrame!.origin.x, y: -.greatestFiniteMagnitude, width: previousFrame!.size.width, height: .infinity)) {
            cells.append([])
        }
        cells[cells.endIndex - 1].append(currentItemAttributes)
        previousFrame = currentItemAttributes.frame
    }
    // 替换为调用独立函数
    return representedElements + cells.flatMap(repositionVerticalGroup)
}

说明 #

• 将嵌套闭包提取为独立函数后，编译器可以单独处理每个函数的类型检查，避免嵌套逻辑带来的复杂度。
• 拆分复杂的数值计算为多个子步骤，减少单表达式的复杂度，帮助编译器更快完成类型推断。
• 额外优化：原代码中直接修改传入的$0.frame，改为创建可变副本mutableAttributes，避免潜在的原数据污染问题（原逻辑是复制过的attributes，所以不影响功能，但更规范）。

内容的提问来源于stack exchange，提问作者mikegrep