test/FixCode/fixits-switch-nonfrozen.swift.result

// RUN: not %target-swift-frontend -emit-sil %s -emit-fixits-path %t.remap -enable-library-evolution -enable-nonfrozen-enum-exhaustivity-diagnostics -diagnostics-editor-mode
// RUN: c-arcmt-test %t.remap | arcmt-test -verify-transformed-files %s.result

enum Runcible {
  case spoon
  case hat
  case fork
}

func checkDiagnosticMinimality(x: Runcible?) {
  switch (x!, x!) {
  case (.spoon, .spoon):
    break
  case (.spoon, .hat):
    break
  case (.hat, .spoon):
    break
  case (.fork, _):
<#code#>
case (.hat, .hat):
<#code#>
case (_, .fork):
<#code#>
}

  switch (x!, x!) {
  case (.spoon, .spoon):
    break
  case (.hat, .hat):
    break
  case (.fork, _):
<#code#>
case (.hat, .spoon):
<#code#>
case (.spoon, .hat):
<#code#>
case (_, .fork):
<#code#>
}
}

enum LargeSpaceEnum {
  case case0
  case case1
  case case2
  case case3
  case case4
  case case5
  case case6
  case case7
  case case8
  case case9
  case case10
}

func notQuiteBigEnough() -> Bool {
  switch (LargeSpaceEnum.case1, LargeSpaceEnum.case2) {
  case (.case0, .case0): return true
  case (.case1, .case1): return true
  case (.case2, .case2): return true
  case (.case3, .case3): return true
  case (.case4, .case4): return true
  case (.case5, .case5): return true
  case (.case6, .case6): return true
  case (.case7, .case7): return true
  case (.case8, .case8): return true
  case (.case9, .case9): return true
  case (.case10, .case10): return true
  case (.case10, .case0):
<#code#>
case (.case10, .case1):
<#code#>
case (.case10, .case2):
<#code#>
case (.case10, .case3):
<#code#>
case (.case10, .case4):
<#code#>
case (.case10, .case5):
<#code#>
case (.case10, .case6):
<#code#>
case (.case10, .case7):
<#code#>
case (.case10, .case8):
<#code#>
case (.case10, .case9):
<#code#>
case (.case9, .case0):
<#code#>
case (.case9, .case1):
<#code#>
case (.case9, .case2):
<#code#>
case (.case9, .case3):
<#code#>
case (.case9, .case4):
<#code#>
case (.case9, .case5):
<#code#>
case (.case9, .case6):
<#code#>
case (.case9, .case7):
<#code#>
case (.case9, .case8):
<#code#>
case (.case9, .case10):
<#code#>
case (.case8, .case0):
<#code#>
case (.case8, .case1):
<#code#>
case (.case8, .case2):
<#code#>
case (.case8, .case3):
<#code#>
case (.case8, .case4):
<#code#>
case (.case8, .case5):
<#code#>
case (.case8, .case6):
<#code#>
case (.case8, .case7):
<#code#>
case (.case8, .case9):
<#code#>
case (.case8, .case10):
<#code#>
case (.case7, .case0):
<#code#>
case (.case7, .case1):
<#code#>
case (.case7, .case2):
<#code#>
case (.case7, .case3):
<#code#>
case (.case7, .case4):
<#code#>
case (.case7, .case5):
<#code#>
case (.case7, .case6):
<#code#>
case (.case7, .case8):
<#code#>
case (.case7, .case9):
<#code#>
case (.case7, .case10):
<#code#>
case (.case6, .case0):
<#code#>
case (.case6, .case1):
<#code#>
case (.case6, .case2):
<#code#>
case (.case6, .case3):
<#code#>
case (.case6, .case4):
<#code#>
case (.case6, .case5):
<#code#>
case (.case6, .case7):
<#code#>
case (.case6, .case8):
<#code#>
case (.case6, .case9):
<#code#>
case (.case6, .case10):
<#code#>
case (.case5, .case0):
<#code#>
case (.case5, .case1):
<#code#>
case (.case5, .case2):
<#code#>
case (.case5, .case3):
<#code#>
case (.case5, .case4):
<#code#>
case (.case5, .case6):
<#code#>
case (.case5, .case7):
<#code#>
case (.case5, .case8):
<#code#>
case (.case5, .case9):
<#code#>
case (.case5, .case10):
<#code#>
case (.case4, .case0):
<#code#>
case (.case4, .case1):
<#code#>
case (.case4, .case2):
<#code#>
case (.case4, .case3):
<#code#>
case (.case4, .case5):
<#code#>
case (.case4, .case6):
<#code#>
case (.case4, .case7):
<#code#>
case (.case4, .case8):
<#code#>
case (.case4, .case9):
<#code#>
case (.case4, .case10):
<#code#>
case (.case3, .case0):
<#code#>
case (.case3, .case1):
<#code#>
case (.case3, .case2):
<#code#>
case (.case3, .case4):
<#code#>
case (.case3, .case5):
<#code#>
case (.case3, .case6):
<#code#>
case (.case3, .case7):
<#code#>
case (.case3, .case8):
<#code#>
case (.case3, .case9):
<#code#>
case (.case3, .case10):
<#code#>
case (.case2, .case0):
<#code#>
case (.case2, .case1):
<#code#>
case (.case2, .case3):
<#code#>
case (.case2, .case4):
<#code#>
case (.case2, .case5):
<#code#>
case (.case2, .case6):
<#code#>
case (.case2, .case7):
<#code#>
case (.case2, .case8):
<#code#>
case (.case2, .case9):
<#code#>
case (.case2, .case10):
<#code#>
case (.case1, .case0):
<#code#>
case (.case1, .case2):
<#code#>
case (.case1, .case3):
<#code#>
case (.case1, .case4):
<#code#>
case (.case1, .case5):
<#code#>
case (.case1, .case6):
<#code#>
case (.case1, .case7):
<#code#>
case (.case1, .case8):
<#code#>
case (.case1, .case9):
<#code#>
case (.case1, .case10):
<#code#>
case (.case0, .case1):
<#code#>
case (.case0, .case2):
<#code#>
case (.case0, .case3):
<#code#>
case (.case0, .case4):
<#code#>
case (.case0, .case5):
<#code#>
case (.case0, .case6):
<#code#>
case (.case0, .case7):
<#code#>
case (.case0, .case8):
<#code#>
case (.case0, .case9):
<#code#>
case (.case0, .case10):
<#code#>
}
}

enum OverlyLargeSpaceEnum {
  case case0
  case case1
  case case2
  case case3
  case case4
  case case5
  case case6
  case case7
  case case8
  case case9
  case case10
  case case11
}

enum ContainsOverlyLargeEnum {
  case one(OverlyLargeSpaceEnum)
  case two(OverlyLargeSpaceEnum)
  case three(OverlyLargeSpaceEnum, OverlyLargeSpaceEnum)
}

func quiteBigEnough() -> Bool {
  switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
  case (.case0, .case0): return true
  case (.case1, .case1): return true
  case (.case2, .case2): return true
  case (.case3, .case3): return true
  case (.case4, .case4): return true
  case (.case5, .case5): return true
  case (.case6, .case6): return true
  case (.case7, .case7): return true
  case (.case8, .case8): return true
  case (.case9, .case9): return true
  case (.case10, .case10): return true
  case (.case11, .case11): return true
  case (.case11, .case0):
<#code#>
case (.case11, .case1):
<#code#>
case (.case11, .case2):
<#code#>
case (.case11, .case3):
<#code#>
case (.case11, .case4):
<#code#>
case (.case11, .case5):
<#code#>
case (.case11, .case6):
<#code#>
case (.case11, .case7):
<#code#>
case (.case11, .case8):
<#code#>
case (.case11, .case9):
<#code#>
case (.case11, .case10):
<#code#>
case (.case10, .case0):
<#code#>
case (.case10, .case1):
<#code#>
case (.case10, .case2):
<#code#>
case (.case10, .case3):
<#code#>
case (.case10, .case4):
<#code#>
case (.case10, .case5):
<#code#>
case (.case10, .case6):
<#code#>
case (.case10, .case7):
<#code#>
case (.case10, .case8):
<#code#>
case (.case10, .case9):
<#code#>
case (.case10, .case11):
<#code#>
case (.case9, .case0):
<#code#>
case (.case9, .case1):
<#code#>
case (.case9, .case2):
<#code#>
case (.case9, .case3):
<#code#>
case (.case9, .case4):
<#code#>
case (.case9, .case5):
<#code#>
case (.case9, .case6):
<#code#>
case (.case9, .case7):
<#code#>
case (.case9, .case8):
<#code#>
case (.case9, .case10):
<#code#>
case (.case9, .case11):
<#code#>
case (.case8, .case0):
<#code#>
case (.case8, .case1):
<#code#>
case (.case8, .case2):
<#code#>
case (.case8, .case3):
<#code#>
case (.case8, .case4):
<#code#>
case (.case8, .case5):
<#code#>
case (.case8, .case6):
<#code#>
case (.case8, .case7):
<#code#>
case (.case8, .case9):
<#code#>
case (.case8, .case10):
<#code#>
case (.case8, .case11):
<#code#>
case (.case7, .case0):
<#code#>
case (.case7, .case1):
<#code#>
case (.case7, .case2):
<#code#>
case (.case7, .case3):
<#code#>
case (.case7, .case4):
<#code#>
case (.case7, .case5):
<#code#>
case (.case7, .case6):
<#code#>
case (.case7, .case8):
<#code#>
case (.case7, .case9):
<#code#>
case (.case7, .case10):
<#code#>
case (.case7, .case11):
<#code#>
case (.case6, .case0):
<#code#>
case (.case6, .case1):
<#code#>
case (.case6, .case2):
<#code#>
case (.case6, .case3):
<#code#>
case (.case6, .case4):
<#code#>
case (.case6, .case5):
<#code#>
case (.case6, .case7):
<#code#>
case (.case6, .case8):
<#code#>
case (.case6, .case9):
<#code#>
case (.case6, .case10):
<#code#>
case (.case6, .case11):
<#code#>
case (.case5, .case0):
<#code#>
case (.case5, .case1):
<#code#>
case (.case5, .case2):
<#code#>
case (.case5, .case3):
<#code#>
case (.case5, .case4):
<#code#>
case (.case5, .case6):
<#code#>
case (.case5, .case7):
<#code#>
case (.case5, .case8):
<#code#>
case (.case5, .case9):
<#code#>
case (.case5, .case10):
<#code#>
case (.case5, .case11):
<#code#>
case (.case4, .case0):
<#code#>
case (.case4, .case1):
<#code#>
case (.case4, .case2):
<#code#>
case (.case4, .case3):
<#code#>
case (.case4, .case5):
<#code#>
case (.case4, .case6):
<#code#>
case (.case4, .case7):
<#code#>
case (.case4, .case8):
<#code#>
case (.case4, .case9):
<#code#>
case (.case4, .case10):
<#code#>
case (.case4, .case11):
<#code#>
case (.case3, .case0):
<#code#>
case (.case3, .case1):
<#code#>
case (.case3, .case2):
<#code#>
case (.case3, .case4):
<#code#>
case (.case3, .case5):
<#code#>
case (.case3, .case6):
<#code#>
case (.case3, .case7):
<#code#>
case (.case3, .case8):
<#code#>
case (.case3, .case9):
<#code#>
case (.case3, .case10):
<#code#>
case (.case3, .case11):
<#code#>
case (.case2, .case0):
<#code#>
case (.case2, .case1):
<#code#>
case (.case2, .case3):
<#code#>
case (.case2, .case4):
<#code#>
case (.case2, .case5):
<#code#>
case (.case2, .case6):
<#code#>
case (.case2, .case7):
<#code#>
case (.case2, .case8):
<#code#>
case (.case2, .case9):
<#code#>
case (.case2, .case10):
<#code#>
case (.case2, .case11):
<#code#>
case (.case1, .case0):
<#code#>
case (.case1, .case2):
<#code#>
case (.case1, .case3):
<#code#>
case (.case1, .case4):
<#code#>
case (.case1, .case5):
<#code#>
case (.case1, .case6):
<#code#>
case (.case1, .case7):
<#code#>
case (.case1, .case8):
<#code#>
case (.case1, .case9):
<#code#>
case (.case1, .case10):
<#code#>
case (.case1, .case11):
<#code#>
case (.case0, .case1):
<#code#>
case (.case0, .case2):
<#code#>
case (.case0, .case3):
<#code#>
case (.case0, .case4):
<#code#>
case (.case0, .case5):
<#code#>
case (.case0, .case6):
<#code#>
case (.case0, .case7):
<#code#>
case (.case0, .case8):
<#code#>
case (.case0, .case9):
<#code#>
case (.case0, .case10):
<#code#>
case (.case0, .case11):
<#code#>
}

  switch (OverlyLargeSpaceEnum.case1, OverlyLargeSpaceEnum.case2) {
  case (.case0, _): return true
  case (.case1, _): return true
  case (.case2, _): return true
  case (.case3, _): return true
  case (.case4, _): return true
  case (.case5, _): return true
  case (.case6, _): return true
  case (.case7, _): return true
  case (.case8, _): return true
  case (.case9, _): return true
  case (.case10, _): return true
  case (.case11, _):
<#code#>
}
}

indirect enum InfinitelySized {
  case one
  case two
  case recur(InfinitelySized)
  case mutualRecur(MutuallyRecursive, InfinitelySized)
}

indirect enum MutuallyRecursive {
  case one
  case two
  case recur(MutuallyRecursive)
  case mutualRecur(InfinitelySized, MutuallyRecursive)
}

func infinitelySized() -> Bool {
  switch (InfinitelySized.one, InfinitelySized.one) {
  case (.one, .one): return true
  case (.two, .two): return true
  case (.recur(_), _):
<#code#>
case (.mutualRecur(_, _), _):
<#code#>
case (.two, .one):
<#code#>
case (.recur(_), .mutualRecur(_, _)):
<#code#>
case (.mutualRecur(_, _), .mutualRecur(_, _)):
<#code#>
case (.one, .two):
<#code#>
case (_, .recur(_)):
<#code#>
case (_, .mutualRecur(_, _)):
<#code#>
}
  
  switch (MutuallyRecursive.one, MutuallyRecursive.one) {
  case (.one, .one): return true
  case (.two, .two): return true
  case (.recur(_), _):
<#code#>
case (.mutualRecur(_, _), _):
<#code#>
case (.two, .one):
<#code#>
case (.recur(_), .mutualRecur(_, _)):
<#code#>
case (.mutualRecur(_, _), .mutualRecur(_, _)):
<#code#>
case (.one, .two):
<#code#>
case (_, .recur(_)):
<#code#>
case (_, .mutualRecur(_, _)):
<#code#>
}
}

public enum NonExhaustive {
  case a, b
}

public enum NonExhaustivePayload {
  case a(Int), b(Bool)
}

@_frozen public enum TemporalProxy {
  case seconds(Int)
  case milliseconds(Int)
  case microseconds(Int)
  case nanoseconds(Int)
  case never
}

// Inlineable code is considered "outside" the module and must include a default
// case.
@inlinable
public func testNonExhaustive(_ value: NonExhaustive, _ payload: NonExhaustivePayload, for interval: TemporalProxy, flag: Bool) {
  switch value {
  case .a: break
  case .b:
<#code#>
@unknown default:
<#code#>
}

  switch value {
  case .a: break
  case .b: break
  @unknown default:
<#fatalError()#>
}
  
  switch value {
  case .a: break
  case .b: break
  default: break // no-warning
  }

  switch value {
  case .a: break
  case .b: break
  @unknown case _: break // no-warning
  }

  switch value {
  case .a: break
  case .b:
<#code#>
@unknown case _: break
  }

  switch value {
  case .a:
<#code#>
case .b:
<#code#>
@unknown case _: break
  }

  // Test being part of other spaces.
  switch value as Optional {
  case .a?: break
  case .b?: break
  case nil: break
  case .some(_):
<#code#>
}

  switch value as Optional {
  case .a?: break
  case .b?: break
  case nil: break
  @unknown case _: break
  } // no-warning

  switch value as Optional {
  case _?: break
  case nil: break
  } // no-warning

  switch (value, flag) {
  case (.a, _): break
  case (.b, false): break
  case (_, true): break
  case (_, false):
<#code#>
}

  switch (value, flag) {
  case (.a, _): break
  case (.b, false): break
  case (_, true): break
  @unknown case _: break
  } // no-warning

  switch (flag, value) {
  case (_, .a): break
  case (false, .b): break
  case (true, _): break
  case (false, _):
<#code#>
}

  switch (flag, value) {
  case (_, .a): break
  case (false, .b): break
  case (true, _): break
  @unknown case _: break
  } // no-warning

  switch (value, value) {
  case (.a, _), (_, .a): break
  case (.b, _), (_, .b): break
  case (_, _):
<#code#>
}

  switch (value, value) {
  case (.a, _), (_, .a): break
  case (.b, _), (_, .b): break
  @unknown case _: break
  } // no-warning

  switch (value, interval) {
  case (_, .seconds): break
  case (.a, _): break
  case (.b, _): break
  case (_, .milliseconds(_)):
<#code#>
case (_, .microseconds(_)):
<#code#>
case (_, .nanoseconds(_)):
<#code#>
case (_, .never):
<#code#>
}

  switch (value, interval) {
  case (_, .never): break
  case (.a, _): break
  case (.b, _): break
  case (_, .seconds(_)):
<#code#>
case (_, .milliseconds(_)):
<#code#>
case (_, .microseconds(_)):
<#code#>
case (_, .nanoseconds(_)):
<#code#>
}

  // Test payloaded enums.
  switch payload {
  case .a: break
  case .b(_):
<#code#>
@unknown default:
<#code#>
}

  switch payload {
  case .a: break
  case .b: break
  @unknown default:
<#fatalError()#>
}
  
  switch payload {
  case .a: break
  case .b: break
  default: break // no-warning
  }

  switch payload {
  case .a: break
  case .b: break
  @unknown case _: break // no-warning
  }

  switch payload {
  case .a: break
  case .b(_):
<#code#>
@unknown case _: break
  }

  switch payload {
  case .a: break
  case .b(false): break
  case .b(true):
<#code#>
@unknown default:
<#code#>
}

  switch payload {
  case .a: break
  case .b(false): break
  case .b(true):
<#code#>
@unknown case _: break
  }
}