Check New nodes for instantiability.

- Abstract classes cannot be instantiated (exceptions:
  parent news and Java annotations)
- Instantiateed class must conform to its self type.

Author: odersky

src/dotty/tools/dotc/typer/Checking.scala

@@ -243,18 +243,21 @@ trait Checking {
 
   /** Check that `tp` is a class type with a stable prefix. Also:
    *  If `traitReq` is true, check that `tp` refers to a trait.
-   *  If `concreteReq` is true, check that `tp` refers to a nonAbstract class. 
+   *  If `concreteReq` is true, check that `tp` refers to a nonAbstract class
+   *  and that the instance conforms to the self type of the created class.
    *  Stability checking is disabled in phases after RefChecks.
    *  @return  `tp` itself if it is a class or trait ref, ObjectClass.typeRef if not.
    */
   def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean = false, concreteReq: Boolean = false)(implicit ctx: Context): Type =
     tp.underlyingClassRef(refinementOK = false) match {
       case tref: TypeRef =>
+        val cls = tref.symbol
         if (ctx.phase <= ctx.refchecksPhase) checkStable(tref.prefix, pos)
-        if (traitReq && !(tref.symbol is Trait)) 
+        if (traitReq && !(cls is Trait)) 
           ctx.error(d"$tref is not a trait", pos)
-        if (concreteReq && false && (tref.symbol is AbstractOrTrait)) 
-          ctx.error(d"${tref.symbol} is abstract; cannot be instantiated, owner = ${ctx.owner}", pos)
+        if (concreteReq) {
+          if (cls.is(AbstractOrTrait))
+            ctx.error(d"$cls is abstract; cannot be instantiated", pos)
         tp
       case _ =>
         ctx.error(d"$tp is not a class type", pos)

src/dotty/tools/dotc/typer/Typer.scala

@@ -348,7 +348,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
       case _ =>
 	      val tpt1 = typedType(tree.tpt)
-	      checkClassTypeWithStablePrefix(tpt1.tpe, tpt1.pos, concreteReq = !ctx.owner.isClass)
+        val cls = tpt1.tpe.classSymbol
+        val isJavaAnnot = 
+          tree.hasAttachment(AnnotNew) && cls.is(JavaDefined) && cls.isAnnotation
+        val canBeAbstract = 
+          tree.hasAttachment(ParentNew) || isJavaAnnot || ctx.isAfterTyper
+        checkClassTypeWithStablePrefix(tpt1.tpe, tree.pos, concreteReq = !canBeAbstract)
         assignType(cpy.New(tree)(tpt1), tpt1)
         // todo in a later phase: checkInstantiatable(cls, tpt1.pos)
     }

test/dotc/tests.scala

@@ -126,6 +126,7 @@ class tests extends CompilerTest {
   @Test def neg_i0281 = compileFile(negDir, "i0281-null-primitive-conforms", xerrors = 3)
   @Test def neg_moduleSubtyping = compileFile(negDir, "moduleSubtyping", xerrors = 4)
   @Test def neg_escapingRefs = compileFile(negDir, "escapingRefs", xerrors = 2)
+  @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
 
   @Test def dotc = compileDir(dotcDir + "tools/dotc", failedOther)(allowDeepSubtypes ++ twice) // see dotc_core

tests/neg/instantiateAbstract.scala

@@ -0,0 +1,38 @@
+abstract class AA
+
+trait TT
+
+class A { self: B =>
+
+}
+
+@scala.annotation.Annotation class C // error
+
+class B extends A() {
+}
+
+object Test {
+
+  @scala.annotation.Annotation type T = String // ok, annotations do not count as new
+  @scala.annotation.Annotation val x = 1 // ok
+  @scala.annotation.Annotation def f = 1 //ok
+
+  (1: @scala.annotation.Annotation) // ok
+
+
+  new AA // error
+
+  new TT // error
+
+  new A // error
+
+// the following are OK in Typer but would be caught later in RefChecks
+
+  new A() {}
+
+  new AA() {}
+
+  object O extends A
+
+  object OO extends AA
+}