On the other hand, as shown below, the compiler indicates a wrong error "case will never be executed" even if it must be executed.

enum E {
  case a // only one case
}

func f(_ e0:E, _ e1:E) {
  switch (e0, e1) {
  case (.a, _): print("e0 is .a")
  }
  
  switch (e0, e1) {
  case (.a, _), (_, .a): print("e0 or e1 is .a") // -> warning: case will never be executed
  }
}

f(.a, .a)

Ah, that second issue is trying to say the second pattern will never match, not the entire case. Can you file a separate bug to clean up that diagnostic?

CodaFi (JIRA User), @xedin, what do you think about this one? Is this supposed to be caught in the Space Engine or in SIL?

@belkadan

Thank you for the advice.

I have posted it as SR-8213.

I think Space Engine should be able to determine that second pattern would never match.

I disagree. If we turned on optimal pattern dispatch in SILGen we could catch this.

Take this code:

func f(_ e0:E, _ e1:E) -> Int {
  switch (e0, e1) {
  case (.a, _): return 11
  case (_, .a): return 22
  case (.b, _): return 33
  default: return 44
  }
}

SIL is essentially emitting this for the switch

if e0 == .a {
  return 11
} else {
  if e1 == .a {
    return 22
  } else {
    if e0 == .b {
      return 33
    } else {
      return 44
    }
  }
}

When it should be emitting this:

if e0 == .a {
  return 11
} else {
  if e1 == .a {
    return 22
  } else {
    return 33
  } /* else { return 44 } <- dead */
}

But we don't specialize inside tuple patterns.