New attachments: ParentNew and AnnotNew

The attachments label `New` nodes that are parents or annotations.
These nodes will be treated specially when it comes to checking whether
a class can be instantiated. Specifically, parents and Java-defined annotations
are allowed to be abstract.

Also: New convenience method: isAnnotation

Author: odersky

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -82,6 +82,12 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case Block(stats, expr) => methPart(expr)
     case mp => mp
   }
+  
+  /** If tree is an instance creation expression, its New node, otherwise tree itself */
+  def newPart(tree: Tree) = methPart(tree) match {
+    case Select(nu: untpd.New, nme.CONSTRUCTOR) => nu
+    case _ => tree
+  }
 
   /** If tree is a closure, it's body, otherwise tree itself */
   def closureBody(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -382,6 +382,10 @@ object SymDenotations {
     /** is this symbol a trait representing a type lambda? */
     final def isLambdaTrait(implicit ctx: Context): Boolean =
       isClass && name.startsWith(tpnme.LambdaPrefix)
+      
+    /** Is this symbol an annotation? */
+    final def isAnnotation(implicit ctx: Context): Boolean =
+      derivesFrom(defn.AnnotationClass)
 
     /** Is this symbol a package object or its module class? */
     def isPackageObject(implicit ctx: Context): Boolean = {
@@ -986,6 +990,9 @@ object SymDenotations {
 
     def nonMemberTermRef(implicit ctx: Context): TermRef =
       TermRef.withFixedSym(owner.thisType, name.asTermName, symbol.asTerm)
+      
+    def typeRefWithArgs(implicit ctx: Context): Type = 
+      typeRef.appliedTo(typeParams.map(_.typeRef))
 
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter

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

@@ -525,6 +525,7 @@ trait Applications extends Compatibility { self: Typer =>
 
       methPart(fun1).tpe match {
         case funRef: TermRef =>
+          labelAnnotArgs(funRef.symbol, tree)
           tryEither { implicit ctx =>
             val app =
               if (proto.argsAreTyped) new ApplyToTyped(tree, fun1, funRef, proto.typedArgs, pt)
@@ -578,6 +579,33 @@ trait Applications extends Compatibility { self: Typer =>
     else realApply
   }
 
+  /** If `meth` is a constructor of a Java annotation used as an annotation
+   *  (as opposed to a normal `new`), label every `new` everywhere in its arguments
+   *  (including nested occurrences) as annotations. 
+   *  See pos/java-interop/t294 for examples.
+   *  This labeling is safe because Java annotations only accept constants and
+   *  other annotations as arguments, so a `new` must be an allocation site for
+   *  an annotation.
+   *  The labeling is necessary because we need to avoid flagging `new`'s of Java
+   *  annotation interfaces as errors because the interface is abstract.
+   */
+  private def labelAnnotArgs(meth: Symbol, app: untpd.Apply)(implicit ctx: Context): Unit = {
+    import untpd._
+    val isJavaAnnot = meth.isConstructor && meth.is(JavaDefined) && meth.owner.isAnnotation
+    if (newPart(app).hasAttachment(AnnotNew) && isJavaAnnot) {
+      val labelNewsAsAnnots = new TreeTraverser {
+        def traverse(tree: untpd.Tree)(implicit ctx: Context): Unit = {
+          tree match {
+            case tree: New => tree.putAttachment(AnnotNew, ())
+            case _ =>
+          }
+          traverseChildren(tree)
+        }
+      }
+      app.args.foreach(labelNewsAsAnnots.traverse)
+    }
+  }
+
   /** Overridden in ReTyper to handle primitive operations that can be generated after erasure */
   protected def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(implicit ctx: Context): Tree =
     throw new Error(s"unexpected type.\n fun = $fun,\n methPart(fun) = ${methPart(fun)},\n methPart(fun).tpe = ${methPart(fun).tpe},\n tpe = ${fun.tpe}")

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

@@ -155,10 +155,21 @@ class Namer { typer: Typer =>
 
   import untpd._
 
+  /** Untyped tree was already typed, the attachment value is its typed versuon */
   val TypedAhead = new Attachment.Key[tpd.Tree]
+
+  /** Tree was expanded to by desugaring; the attachment value is its expansion */
   val ExpandedTree = new Attachment.Key[Tree]
+
+  /** Tree has been assigned a symbol, which is the attachment value */
   val SymOfTree = new Attachment.Key[Symbol]
 
+  /** `New` node is part of a parent constructor of a class, and can therefore be abstract */
+  val ParentNew = new Attachment.Key[Unit]
+
+  /** `New` node is an annotation, can be abstract if the annotation is Java defined */
+  val AnnotNew = new Attachment.Key[Unit]
+
   /** A partial map from unexpanded member and pattern defs and to their expansions.
    *  Populated during enterSyms, emptied during typer.
    */
@@ -528,7 +539,8 @@ class Namer { typer: Typer =>
             case TypeApply(core, targs) => (core, targs)
             case core => (core, Nil)
           }
-          val Select(New(tpt), nme.CONSTRUCTOR) = core
+          val Select(nu @ New(tpt), nme.CONSTRUCTOR) = core
+          nu.putAttachment(ParentNew, ())
           val targs1 = targs map (typedAheadType(_))
           val ptype = typedAheadType(tpt).tpe appliedTo targs1.tpes
           if (ptype.typeParams.isEmpty) ptype

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

@@ -25,7 +25,7 @@ import EtaExpansion.etaExpand
 import dotty.tools.dotc.transform.Erasure.Boxing
 import util.Positions._
 import util.common._
-import util.SourcePosition
+import util.{SourcePosition, Attachment}
 import collection.mutable
 import annotation.tailrec
 import Implicits._
@@ -868,7 +868,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedAnnotation(annot: untpd.Tree)(implicit ctx: Context): Tree = track("typedAnnotation") {
-    typed(annot, defn.AnnotationClass.typeRef)
+    labelNew(annot, AnnotNew)
+    typedExpr(annot, defn.AnnotationClass.typeRef)
   }
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(implicit ctx: Context) = track("typedValDef") {
@@ -940,11 +941,20 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    */
   def ensureConstrCall(cls: ClassSymbol, parents: List[Tree])(implicit ctx: Context): List[Tree] = {
     val firstParent :: otherParents = parents
-    if (firstParent.isType && !(cls is Trait))
-      typed(untpd.New(untpd.TypedSplice(firstParent), Nil)) :: otherParents
-    else parents
+    if (firstParent.isType && !(cls is Trait)) {
+      val constr = untpd.New(untpd.TypedSplice(firstParent), Nil)
+      labelNew(constr, ParentNew)
+      typed(constr) :: otherParents
+    } else parents
   }
 
+  /** If `tree` is an instance creation expression, attach the given label to its `New` node */
+  def labelNew(tree: untpd.Tree, label: Attachment.Key[Unit]): Unit = 
+    untpd.newPart(tree) match {
+      case nu: untpd.New => nu.putAttachment(label, ())
+      case _ =>
+    }
+
   /** Overridden in retyper */
   def checkVariance(tree: Tree)(implicit ctx: Context) = VarianceChecker.check(tree)
 
@@ -971,7 +981,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(implicit ctx: Context): Tree = track("typedAnnotated") {
-    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    val annot1 = typedAnnotation(tree.annot)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type)
       assignType(cpy.Annotated(tree)(annot1, arg1), annot1, arg1)