[SR-15516] Unable to type-check expression with bitwise operations

[swift-ci]

Previous ID	SR-15516
Radar	None
Original Reporter	0xF (JIRA User)
Type	Bug

Environment

swiftc --version
compnerd.org Swift version 5.5.1 (swift-5.5.1-RELEASE)
Target: x86_64-unknown-windows-msvc

Additional Detail from JIRA

Votes	0
Component/s
Labels	Bug
Assignee	None
Priority	Medium

md5: 5a1c67b4ede674847b863256b69c4264

Issue Description:

This code fails to compile:

func plotSpcPattern(x : Int, y : Int, pattern : Int) -> UInt8
{
    return UInt8(pattern >> ((~y & 1) * 8 + (~x & 3) * 2) & 3)
}

The compiler outputs after about a minute:

swiftc -c -no-color-diagnostics reasonable.swift
reasonable.swift:3:9: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 return UInt8(pattern >> ((~y & 1) * 8 + (~x & 3) * 2) & 3)
 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Exit code: 1

What is here to type-check? The function performs a bitwise AND with the literal 3, hence it returns values between 0 and 3.

[swift-ci]

Comment by Berik Visschers (JIRA)

First a disclaimer: I'm not an expert on the swift type system internals.

The way the swift compiler does type validation makes expressions with many operators and numeric literals (more than.. ehm.. 5) very slow to validate. To avoid long compile times, the swift compiler throws an error instead. This is a known issue and existed from the start of Swift. There has been progress to make the swift compiler faster and emit fewer errors in past versions. There is currently work under way to further improve Swifts type checker, which will likely change the situation you described.

What makes this so slow?

An expression like `let a = 3` has two untyped parts on both sides of the equal sign. Swift will infer the type of the literal 3 first based on the context (eg: `let a: Float = 3` would make the literal 3 a Float). Only after that the variable can be typed. In the case of no specified types, swift will pick the default type (a literal like 3 has a default type of Int).

Operators provide another level of search space. In the expression `let a = 3 + 4` the swift type system will try to infer the types of both literals based on the constraints left on the equal sign as well as the available overloads of the plus operator. Untyped literals make finding the right overload slightly harder for the type system.

One solution would be to split up any line with multiple numeric literals and operators into multiple lines. Another solution is to explicitly type the literals like `let a = Int(3) + 4`. Going that far, it may be worth to just have typed variables in the calculation (avoiding unnamed aka magic numbers).

Hope this helps.

For further reading:

Swifts type checker documentation

Swift forum post on current type checker limitations

A blog about a rewrite of the Swift type checker

[slavapestov]

Too complex in 6.1 and 6.2, fast on main. I'll add a regression test.