relates to:

• SR-13707 Fix-it for missing let/var in ill-typed expression pattern

Issue Description:

The problem with this code:

enum List {
    indirect case Cons(Int, List)
    case Nil
}

func head(_ lst : List) -> Int? {
    switch lst {
        case .Cons(hd, _): return hd
        case .Nil: return nil
    }
}

let lst = List.Cons(1, List.Nil)
if let h = head(lst) {
    print(h)
}

is that the programmer forgot to write `case let` or `case var` to introduce a new binding in the pattern for Cons. Because of this, the compiler interpreted it as an expression pattern and reports:

missing_let_int.swift:9:20: error: cannot find 'hd' in scope
        case .Cons(hd, _): return hd
                   ^~
missing_let_int.swift:9:35: error: cannot find 'hd' in scope
        case .Cons(hd, _): return hd
                                  ^~

I think it would be helpful to have a fix-it suggesting that they add a let / var, since no `hd` exists in the scope.

In some situations, this fix-it should not be emitted, such as:

switch (1, 2) {
  case (var a, a): ()
}

where a suggestion to add 'let' or 'var' for the second sub-pattern in the tuple will introduce an invalid redeclaration of 'a'. In this next situation, a different fix-it would be better for the two unbound identifiers:

enum Color {
  case gray
}

let x : Color? = nil
switch x {
  case none: ()
  case .some(gray): ()
}

Based on the type of the switch's scrutinee and the patterns themselves, a better fix-it would be to suggest adding a dot in front of `none` and `gray`. This way, they'll refer to their respective enums (Optional<T> and Color) because their names match one of the enums variants exactly. The better fix-it is most likely what the programmer intended instead of introducing a new binding.