For example, see https://bugs.swift.org/browse/SR-9426

Mind if I take this one? I will probably need a bit of guidance. I looked at the ICMP_EQ builtin, that got me started, but I am not exactly sure what method to use when comparing the strings themselves. Maybe just calling strcmp will be good enough?

String honors Unicode Canonical Equivalence, so you will need to do the same. If you look at StringComparison.swift, you'll see the underlying methods to call for comparison. The series of `if` checks redundantly introspects the string being switched over, while a multi-compare function could introspect the string once.

@eeckstein might be able to help you with the compiler-library interface. We want the function to take many strings to compare against, but don't want to actually allocate an array for the arguments.

I did briefly look at the implementation in the standard library. Thanks for the overview of the requirements. I will reach out to Erik and work on this a bit more tomorrow. I will post my questions here unless there is a better place.

Thanks for the quick response and help.

We already have this kind of thing for the init(rawValue: String) of string enums.
You might want to look at #11936
The library functions in https://github.com/apple/swift/blob/master/stdlib/public/core/StringSwitch.swift could also be used for general String switches or cascades of if-String-comparisons.
A String switch could be replaced by a call to _findStringSwitchCase/_findStringSwitchCaseWithCache and then switched over the returned integer (which can then be optimized by LLVM into a jump table).

Thanks @eeckstein! I will play around with that a bit today and see if I can get something working.

To clarify the goal, we want something like the following to produce a single block of assembly with no jumps (like what would happen if the arguments of type String were replaced with type Int):

func test(a: String, b: String, c: String, d: String) -> Bool {
    if a == b {
        if b == c {
            return c == d
        }
        return false
    }
    return false
}

In this case, the compiler would have to realize that there was a nested set of if-statments and optimize those out. What would be the best method to do this? I assume it should be done in the SILOptimizer. In the PR you linked, you replace one string comparison function with another, would a function like that suffice, or is more complicated logic required?

I don't think this is an important code pattern to optimize. It's doable in the optimizer, but it's very specific and there must be a good reason to optimize this kind of pattern.
IMO, the important scenario is if a (non constant) string value is compared against multiple string constants, like in https://github.com/apple/swift/blob/master/benchmark/single-source/Calculator.swift

I see. So the optimization is inlining all the comparisons, so fewer branches are created?

This is a slightly different issue but, I find it interesting that the assembly produced by the following program does not change significantly when `input` is switched on instead of `x`:

let x = "0"

func test(input: String) -> Int {
  switch x {
    case "0": return 0
    case "1": return 1
    case "2": return 2
    case "3": return 3
    case "4": return 4
    case "5": return 5
    case "6": return 6
    case "7": return 7
    case "8": return 8
    case "9": return 9
    default: return 0
  }
}