Warn if type argument was inferred as union type

Author: Alex1005a

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -169,6 +169,7 @@ private sealed trait WarningSettings:
   private val WtoStringInterpolated = BooleanSetting(WarningSetting, "Wtostring-interpolated", "Warn a standard interpolator used toString on a reference type.")
   private val WrecurseWithDefault = BooleanSetting(WarningSetting, "Wrecurse-with-default", "Warn when a method calls itself with a default argument.")
   private val WwrongArrow = BooleanSetting(WarningSetting, "Wwrong-arrow", "Warn if function arrow was used instead of context literal ?=>.")
+  private val WinferUnion = BooleanSetting(WarningSetting, "Winfer-union", "Warn if type argument was inferred as union type.")
   private val Wunused: Setting[List[ChoiceWithHelp[String]]] = MultiChoiceHelpSetting(
     WarningSetting,
     name = "Wunused",
@@ -307,6 +308,7 @@ private sealed trait WarningSettings:
     def toStringInterpolated(using Context): Boolean = allOr(WtoStringInterpolated)
     def recurseWithDefault(using Context): Boolean = allOr(WrecurseWithDefault)
     def wrongArrow(using Context): Boolean = allOr(WwrongArrow)
+    def inferUnion(using Context): Boolean = allOr(WinferUnion)
     def safeInit(using Context): Boolean = allOr(WsafeInit)
 
 /** -X "Extended" or "Advanced" settings */

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -534,6 +534,16 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
             Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
+          if ctx.settings.Whas.inferUnion then
+            val inferredOrTypes = args.filter(tpt =>
+              tpt.isInstanceOf[InferredTypeTree] && tpt.tpe.stripTypeVar.isInstanceOf[OrType]
+            )
+            inferredOrTypes.headOption.foreach(tpt =>
+              report.warning(
+                em"""|A type argument was inferred to be union type ${tpt.tpe.stripTypeVar}
+                     |This may indicate a programming error.
+                     |""", tpt.srcPos)
+            )
           fn match {
             case sel: Select =>
               val args1 = transform(args)

tests/warn/infer-or-type.scala

@@ -0,0 +1,8 @@
+//> using options -Winfer-union
+
+case class Pair[A](x: A, y: A)
+
+def test = {
+  val _ = List(1).contains("") // warn
+  val _ = Pair(1, "") // warn
+}