Typing deviation in getOrElse

[DarkDimius]

import scala.collection._
object T {
  val newSymbolMap: mutable.HashMap[String, mutable.HashMap[Int, Double]] = mutable.HashMap.empty
  val map = newSymbolMap.getOrElse("a", mutable.HashMap.empty)
  map.put(1, 0.0)
  newSymbolMap.put("a", map)
}

Compiles fine with scalac. Fails in dotty:

reproduce.scala:5: error: type mismatch:
 found   : Int(1)
 required: T.map.A
  map.put(1, 0.0)
          ^
reproduce.scala:5: error: type mismatch:
 found   : Double(0.0)
 required: T.map.B
  map.put(1, 0.0)
             ^
reproduce.scala:6: error: type mismatch:
 found   : (scala.collection.mutable.HashMap[Int, Double] |
  scala.collection.mutable.HashMap[Nothing, Nothing]
)(T.map)
 required: collection.mutable.HashMap[Int, Double]
  newSymbolMap.put("a", map)
                        ^
three warnings found
three errors found

This code is part of #630 and it used to compile fine.

[DarkDimius]

Specifying the type of map: mutable.HashMap[Int, Double] is a workaround.

[smarter]

Quick analysis which might be wrong, I haven't checked it:
When we do type inference for newSymbolMap.getOrElse we start with:

B1 >: scala.collection.mutable.HashMap[Int, Double]

where B1 corresponds to the type parameter of getOrElse, then since we apply it to ("a", mutable.HashMap.empty), we get:

B1 >: scala.collection.mutable.HashMap[Int, Double] | scala.collection.mutable.HashMap[A, B]
A unconstrained
B unconstrained

where A and B correspond to the type parameters of HashMap.empty.

Afterwards, we instantiate the tvars:

1. B1 is instantiated to scala.collection.mutable.HashMap[Int, Double] | scala.collection.mutable.HashMap[A, B] (the union is not approximated because it contains uninstantiated tvars, this is false, see next comment)
2. A and B are instantiated to Nothing because they are unconstrained

I'm not sure how to fix this right now.

[smarter]

Actually, the issue seems to be in approximateUnion which we do call on scala.collection.mutable.HashMap[Int, Double] | scala.collection.mutable.HashMap[A, B], it should return a non-union type (and thus constrain A and B properly and fix the issue we're seeing) but it calls baseTypeWithArgs which calls | (https://github.com/lampepfl/dotty/blob/93dd1cf1fdbf56ca3c153aa5a25fb4c48782acf5/src/dotty/tools/dotc/core/TypeApplications.scala#L610-L611) and we end up back with a union type. This is the case since ee76fda which changed the behavior of |.

This should be easy to fix: instead of calling | in baseTypeWithArgs we should call a method that does distribute unions inside refinement types because this is what we want in this particular case.