Imported From: https://issues.scala-lang.org/browse/SI-10019?orig=1
Reporter: @refried
Affected Versions: 2.11.8, 2.12.0
See #6450

@SethTisue said:
offhand, it looks similar to #6450. does it seem like a duplicate to you? or so close that it ought to just be a comment on that ticket? or is this actually quite distinct?

@refried said (edited on Nov 7, 2016 8:37:19 PM UTC):
Hmm, I don't claim to be an expert, but I think they are quite distinct. #6450 shows a false-positive in a seemingly yucky match involving wildcard types and .isInstanceOf and working directly with the Some class instead of Option class.

#10019 (this ticket) shows a false-negative in a seemingly very simple case.

@SethTisue said:
doh, I should have noticed the other one is false-positive. okay, thanks

@SethTisue said:
@adriaanm hesitating before just throwing this in the "Backlog" bucket, what do you think?

@refried said:
If the goal is to get someone to take a look at it, then why not :-D

@refried said (edited on Nov 11, 2016 10:43:07 PM UTC):
I found this surprising too:

def foo(t1: List[T], t2: List[T]) = (t1, t2) match {
  case (Nil, Nil) => ()
}

This code issues a warning:

[warn] It would fail on the following inputs: (List(_), List(_)), (List(_), Nil), (Nil, List(_))}

But this code issues no warnings:

def foo(t1: List[T], t2: List[T]) = (t1, t2) match {
  case (Nil, Nil) => ()
  case (List(_), List(_)) => ()
}

even though there are still missing cases.

Do you think it's related?

@refried said:
I'm trying to write a more complicated set of match expressions and I would love to feel confident that I wasn't forgetting anything.

Here's another similar case:

    val x: (Option[String], Option[String])  = (None, None)
    x match {
      case (Some(str), None) => println(s"$str, None")
      case (None, Some(str)) => println(s"None, $str")
      case (Some(strA), Some(strB)) if strA == strB => ???
    }

Note that removing the if strA == strB does correctly emit the warning.

@aklosslp that looks like #5365 to me

Yep I agree.

I know Tuple2 isn't sealed

It's final which is even better! So that should not matter.

But this code issues no warnings:

def foo(t1: List[T], t2: List[T]) = (t1, t2) match {
  case (Nil, Nil) => ()
  case (List(_), List(_)) => ()
}

even though there are still missing cases.

Btw, that's because that's using List#unapplySeq, which is #9232 (and specifically mentions List). It's particularly bad because ::'s toString returns List(_) instead of _ :: _.

(I'm going to consider this issue specific to tuples.)

I found this surprising too:

def foo(t1: List[T], t2: List[T]) = (t1, t2) match {
  case (Nil, Nil) => ()
}

This code issues a warning:

[warn] It would fail on the following inputs: (List(_), List(_)), (List(_), Nil), (Nil, List(_))}

But this code issues no warnings:

def foo(t1: List[T], t2: List[T]) = (t1, t2) match {
  case (Nil, Nil) => ()
  case (List(_), List(_)) => ()
}

even though there are still missing cases.

Relevant commentary in the pattern matcher:

      // special-case: interpret pattern `List()` as `Nil`
      // TODO: make it more general List(1, 2) => 1 :: 2 :: Nil  -- not sure this is a good idea...
      private val rewriteListPattern: PartialFunction[TreeMaker, Prop] = {
        case p @ ExtractorTreeMaker(_, _, testedBinder)
          if testedBinder.tpe.typeSymbol == ListClass && p.checkedLength == Some(0) =>
            uniqueEqualityProp(binderToUniqueTree(p.prevBinder), unique(Ident(NilModule) setType NilModule.tpe))
      }

😄

I'm going to leave out this part, as, as I said, it's more generally covered by #9232.

Fixed in scala/scala#9147.