Imported From: https://issues.scala-lang.org/browse/SI-4110?orig=1
Reporter: AlexK (alexk)

@adriaanm said:
test case:

object Test extends Application {
  def inferredType[T : Manifest](v : T) = println(manifest[T])

  trait A
  trait B
  inferredType(new A with B)

  val name = new A with B
  inferredType(name)
}

the relevant fragment (abridged) after typer (with -Ydebug -uniqid):
(note the type argument to inferredType in the very first line!)

    inferredType[anonymous class $$anon$$13406]({
      final class $$anon$$13406 extends Object with A with B ;
      new $$anon$$13406.this()
    })(Manifest.classType[anonymous class $$anon$$13406](classOf[Test$$$$<local Test>$$$$anon]));

    private[this] val name: Object with A with B{} = {
      final class $$anon$$9257 extends Object with A with B ;
      new $$anon$$9257.this()
    };
    inferredType[Object with A with B{}](name)(Manifest.intersectionType[Object with A with B{}](Manifest.Object, Manifest.classType[A](classOf[Test$$$$A]), Manifest.classType[B](classOf[Test$$$$B])))

question: is the symbol $$anon$$13406 supposed to be in scope in inferredType's type argument??
(probably not)

@adriaanm said:
note that the existentials from the original report stem from the REPL -- replaying his transcript with debugging output:

val res0: Manifest[$$anon$$34941] forSome { type $$anon$$34941 <: Object with A with B{} } = 
  inferredType[anonymous class $$anon$$34870]({
      final class $$anon$$34870 extends Object with A with B
      new $$anon$$34870.this()
    })(Manifest.classType[anonymous class $$anon$$34870](classOf[line4$$object$$$$$$iw$$$$iw$$res0 $$$$anon]));

the RHS is essentially the same as in a full scalac run, but the computed type for res0 is packed to get rid of the reference to the anonymous class

Martin, I'm reassigning to you for a hint or two on how to tackle this

Commit Message Bot (anonymous) said:
(extempore in r25161) Don't infer anonymous classes. The type is widened as little as
possible, just far enough to avoid all kinds of undesirable consequences
which accompany the preservation of too much type information. (The
problems are akin to inferring the singleton type too freely.)

// Example of code which did not compile, but now does
class A
class B[T <: A](cons: T)
object C extends B(new A {})

Closes #4110, #3048. I already ran this by moors, so review by odersky.