Syntax for computed type definitions

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -201,7 +201,7 @@ object desugar {
       case (vparam :: vparams) :: vparamss1 =>
         def defaultGetter: DefDef =
           DefDef(
-            name = DefaultGetterName(meth.name, n),
+            name = DefaultGetterName(meth.name.asTermName, n),
             tparams = meth.tparams.map(tparam => dropContextBound(toDefParam(tparam))),
             vparamss = takeUpTo(normalizedVparamss.nestedMap(toDefParam), n),
             tpt = TypeTree(),

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

@@ -339,6 +339,12 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case _ => false
   }
 
+  /** Is this the RHS of a transparnt type def, which needs to be represented as a DefDef? */
+  def isTypeDefRHS(tree: Tree): Boolean = tree match {
+    case tree: If => true
+    case _ => false
+  }
+
   // todo: fill with other methods from TreeInfo that only apply to untpd.Tree's
 }
 

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -492,8 +492,10 @@ object Trees {
 
   /** if cond then thenp else elsep */
   case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
-    extends TermTree[T] {
+    extends Tree[T] {
     type ThisTree[-T >: Untyped] = If[T]
+    override def isTerm = thenp.isTerm
+    override def isType = thenp.isType
   }
 
   /** A closure with an environment and a reference to a method.
@@ -697,8 +699,11 @@ object Trees {
     protected def force(x: AnyRef) = preRhs = x
   }
 
-  /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */
-  case class DefDef[-T >: Untyped] private[ast] (name: TermName, tparams: List[TypeDef[T]],
+  /**     mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs
+   *  or
+   *      mods type[tparams](vparams_1)...(vparams_n): tpt = rhs
+   */
+  case class DefDef[-T >: Untyped] private[ast] (name: Name, tparams: List[TypeDef[T]],
       vparamss: List[List[ValDef[T]]], tpt: Tree[T], private var preRhs: LazyTree)
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
@@ -1085,7 +1090,7 @@ object Trees {
         case tree: ValDef if (name == tree.name) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
         case _ => finalize(tree, untpd.ValDef(name, tpt, rhs))
       }
-      def DefDef(tree: Tree)(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree): DefDef = tree match {
+      def DefDef(tree: Tree)(name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree): DefDef = tree match {
         case tree: DefDef if (name == tree.name) && (tparams eq tree.tparams) && (vparamss eq tree.vparamss) && (tpt eq tree.tpt) && (rhs eq tree.unforcedRhs) => tree
         case _ => finalize(tree, untpd.DefDef(name, tparams, vparamss, tpt, rhs))
       }
@@ -1132,7 +1137,7 @@ object Trees {
         UnApply(tree: Tree)(fun, implicits, patterns)
       def ValDef(tree: ValDef)(name: TermName = tree.name, tpt: Tree = tree.tpt, rhs: LazyTree = tree.unforcedRhs): ValDef =
         ValDef(tree: Tree)(name, tpt, rhs)
-      def DefDef(tree: DefDef)(name: TermName = tree.name, tparams: List[TypeDef] = tree.tparams, vparamss: List[List[ValDef]] = tree.vparamss, tpt: Tree = tree.tpt, rhs: LazyTree = tree.unforcedRhs): DefDef =
+      def DefDef(tree: DefDef)(name: Name = tree.name, tparams: List[TypeDef] = tree.tparams, vparamss: List[List[ValDef]] = tree.vparamss, tpt: Tree = tree.tpt, rhs: LazyTree = tree.unforcedRhs): DefDef =
         DefDef(tree: Tree)(name, tparams, vparamss, tpt, rhs)
       def TypeDef(tree: TypeDef)(name: TypeName = tree.name, rhs: Tree = tree.rhs): TypeDef =
         TypeDef(tree: Tree)(name, rhs)

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -294,7 +294,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Alternative(trees: List[Tree]): Alternative = new Alternative(trees)
   def UnApply(fun: Tree, implicits: List[Tree], patterns: List[Tree]): UnApply = new UnApply(fun, implicits, patterns)
   def ValDef(name: TermName, tpt: Tree, rhs: LazyTree): ValDef = new ValDef(name, tpt, rhs)
-  def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
+  def DefDef(name: Name, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
   def TypeDef(name: TypeName, rhs: Tree): TypeDef = new TypeDef(name, rhs)
   def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: LazyTreeList): Template = new Template(constr, parents, self, body)
   def Import(expr: Tree, selectors: List[untpd.Tree]): Import = new Import(expr, selectors)

compiler/src/dotty/tools/dotc/core/Comments.scala

@@ -121,7 +121,7 @@ object Comments {
 
           tree match {
             case tree: untpd.DefDef =>
-              val newName = ctx.freshNames.newName(tree.name, NameKinds.DocArtifactName)
+              val newName = ctx.freshNames.newName(tree.name.toTermName, NameKinds.DocArtifactName)
               untpd.DefDef(newName, tree.tparams, tree.vparamss, tree.tpt, tree.rhs)
             case _ =>
               ctx.error(ProperDefinitionNotFound(), codePos)

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -784,7 +784,7 @@ object JavaParsers {
           // If the annotation has a default value we don't need to parse it, providing
           // any value at all is enough to typecheck usages of annotations correctly.
           val defaultParam = if (hasDefault) unimplementedExpr else EmptyTree
-          makeParam(dd.name, dd.tpt, defaultParam)
+          makeParam(dd.name.asTermName, dd.tpt, defaultParam)
       }
       val constr = DefDef(nme.CONSTRUCTOR,
         List(), List(constructorParams), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined))

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -46,7 +46,7 @@ object Parsers {
   }
 
   @sharable object ParamOwner extends Enumeration {
-    val Class, Type, TypeParam, Def = Value
+    val Class, Type, TypeParam, Def, Constructor = Value
   }
 
   private implicit class AddDeco(val buf: ListBuffer[Tree]) extends AnyVal {
@@ -714,6 +714,7 @@ object Parsers {
     }
 
 /* ------------- TYPES ------------------------------------------------------ */
+
     /** Same as [[typ]], but if this results in a wildcard it emits a syntax error and
      *  returns a tree for type `Any` instead.
      */
@@ -1055,6 +1056,21 @@ object Parsers {
         case None => t
       }
 
+    /** TypeRHS   ::=  ‘if’ Expr ‘then’ TypeRHS ‘else’ TypeRHS
+     *              |  Type
+     */
+    def typeRHS(): Tree =
+      if (in.token == IF)
+        atPos(in.skipToken()) {
+          val cond = typeRHS()
+          accept(THEN)
+          val thenp = typeRHS()
+          accept(ELSE)
+          val elsep = expr()
+          If(cond, thenp, elsep)
+        }
+      else toplevelTyp()
+
 /* ----------- EXPRESSIONS ------------------------------------------------ */
 
     /** EqualsExpr ::= `=' Expr
@@ -1831,14 +1847,15 @@ object Parsers {
      */
     def typeParamClause(ownerKind: ParamOwner.Value): List[TypeDef] = inBrackets {
       def typeParam(): TypeDef = {
-        val isConcreteOwner = ownerKind == ParamOwner.Class || ownerKind == ParamOwner.Def
+        val isDefOwner = ownerKind == ParamOwner.Def || ownerKind == ParamOwner.Constructor
+        val isConcreteOwner = isDefOwner || ownerKind == ParamOwner.Class
         val start = in.offset
         val mods = atPos(start) {
           annotsAsMods() | {
             if (ownerKind == ParamOwner.Class) Param | PrivateLocal
             else Param
           } | {
-            if (ownerKind != ParamOwner.Def)
+            if (!isDefOwner)
               if (isIdent(nme.raw.PLUS)) { in.nextToken(); Covariant }
               else if (isIdent(nme.raw.MINUS)) { in.nextToken(); Contravariant }
               else EmptyFlags
@@ -1875,14 +1892,14 @@ object Parsers {
      *  DefParam          ::=  {Annotation} [`inline'] Param
      *  Param             ::=  id `:' ParamType [`=' Expr]
      */
-    def paramClauses(owner: Name, ofCaseClass: Boolean = false): List[List[ValDef]] = {
+    def paramClauses(ownerKind: ParamOwner.Value, ofCaseClass: Boolean = false): List[List[ValDef]] = {
       var imods: Modifiers = EmptyModifiers
       var implicitOffset = -1 // use once
       var firstClauseOfCaseClass = ofCaseClass
       def param(): ValDef = {
         val start = in.offset
         var mods = annotsAsMods()
-        if (owner.isTypeName) {
+        if (ownerKind == ParamOwner.Class) {
           mods = addFlag(modifiers(start = mods), ParamAccessor)
           mods =
             atPos(start, in.offset) {
@@ -1909,7 +1926,7 @@ object Parsers {
         atPos(start, nameStart) {
           val name = ident()
           accept(COLON)
-          if (in.token == ARROW && owner.isTypeName && !(mods is Local))
+          if (in.token == ARROW && ownerKind == ParamOwner.Class && !(mods is Local))
             syntaxError(VarValParametersMayNotBeCallByName(name, mods is Mutable))
           val tpt = paramType()
           val default =
@@ -1936,7 +1953,7 @@ object Parsers {
               funArgMods()
             }
           }
-          funArgMods()
+          if (ownerKind != ParamOwner.Type) funArgMods()
 
           commaSeparated(() => param())
         }
@@ -1953,7 +1970,7 @@ object Parsers {
       }
       val start = in.offset
       val result = clauses()
-      if (owner == nme.CONSTRUCTOR && (result.isEmpty || (result.head take 1 exists (_.mods is Implicit)))) {
+      if (ownerKind == ParamOwner.Constructor && (result.isEmpty || (result.head take 1 exists (_.mods is Implicit)))) {
         in.token match {
           case LBRACKET   => syntaxError("no type parameters allowed here")
           case EOF        => incompleteInputError(AuxConstructorNeedsNonImplicitParameter())
@@ -2121,7 +2138,7 @@ object Parsers {
       }
       if (in.token == THIS) {
         in.nextToken()
-        val vparamss = paramClauses(nme.CONSTRUCTOR)
+        val vparamss = paramClauses(ParamOwner.Constructor)
         if (in.isScala2Mode) newLineOptWhenFollowedBy(LBRACE)
         val rhs = {
           if (!(in.token == LBRACE && scala2ProcedureSyntax(""))) accept(EQUALS)
@@ -2132,7 +2149,7 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val name = ident()
         val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val vparamss = paramClauses(name)
+        val vparamss = paramClauses(ParamOwner.Def)
         var tpt = fromWithinReturnType(typedOpt())
         if (in.isScala2Mode) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
@@ -2183,19 +2200,27 @@ object Parsers {
         Block(stats, Literal(Constant(())))
       }
 
-    /** TypeDef ::= type id [TypeParamClause] `=' Type
-     *  TypeDcl ::= type id [TypeParamClause] TypeBounds
+    /** TypeDcl  ::=  id [TypTypeParamClause] {DefParamClause} [‘:’ Type] ‘=’ TypeRHS
+     *             |  id [HkTypeParamClause] TypeBounds
      */
     def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
       newLinesOpt()
       atPos(start, nameStart) {
         val name = ident().toTypeName
         val tparams = typeParamClauseOpt(ParamOwner.Type)
+        val vparamss = paramClauses(ParamOwner.Type)
+        val tpt = typedOpt()
+        val isDef = !vparamss.isEmpty || !tpt.isEmpty
         in.token match {
           case EQUALS =>
             in.nextToken()
-            TypeDef(name, lambdaAbstract(tparams, toplevelTyp())).withMods(mods).setComment(in.getDocComment(start))
+            val rhs = typeRHS()
+            val res =
+              if (isTypeDefRHS(rhs) || isDef) DefDef(name, tparams, vparamss, tpt, rhs)
+              else TypeDef(name, lambdaAbstract(tparams, rhs))
+            res.withMods(mods).setComment(in.getDocComment(start))
           case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | EOF =>
+            if (isDef) syntaxError("`=' expected")
             TypeDef(name, lambdaAbstract(tparams, typeBounds())).withMods(mods).setComment(in.getDocComment(start))
           case _ =>
             syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
@@ -2245,7 +2270,7 @@ object Parsers {
     def classConstr(owner: Name, isCaseClass: Boolean = false): DefDef = atPos(in.lastOffset) {
       val tparams = typeParamClauseOpt(ParamOwner.Class)
       val cmods = fromWithinClassConstr(constrModsOpt(owner))
-      val vparamss = paramClauses(owner, isCaseClass)
+      val vparamss = paramClauses(ParamOwner.Class, isCaseClass)
       makeConstructor(tparams, vparamss).withMods(cmods)
     }
 

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1260,7 +1260,7 @@ object messages {
            |""".stripMargin
   }
 
-  case class OverloadedOrRecursiveMethodNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
+  case class OverloadedOrRecursiveMethodNeedsResultType(tree: Names.Name)(implicit ctx: Context)
   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
     val kind = "Syntax"
     val msg = hl"""overloaded or recursive method ${tree} needs return type"""

docs/docs/internals/syntax.md

@@ -151,6 +151,9 @@ NamedTypeArgs     ::=  ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’
 Refinement        ::=  ‘{’ [RefineDcl] {semi [RefineDcl]} ‘}’                   ds
 TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type] | INT                            TypeBoundsTree(lo, hi)
 TypeParamBounds   ::=  TypeBounds {‘<%’ Type} {‘:’ Type}                        ContextBounds(typeBounds, tps)
+
+TypeRHS           ::=  ‘if’ Expr ‘then’ TypeRHS ‘else’ TypeRHS                  If(cond, thenp, elsep)
+                    |  Type
 ```
 
 ### Expressions
@@ -310,7 +313,8 @@ ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig [‘:’ Type]                                        DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
 DefSig            ::=  id [DefTypeParamClause] DefParamClauses
-TypeDcl           ::=  id [TypTypeParamClause] [‘=’ Type]                       TypeDefTree(_, name, tparams, tpt)
+TypeDcl           ::=  id [TypTypeParamClause] {DefParamClause} [‘:’ Type]      TypeDefTree(_, name, tparams, tpt)
+                       ‘=’ TypeRHS
                     |  id [HkTypeParamClause] TypeBounds                        TypeDefTree(_, name, tparams, bounds)
 
 Def               ::=  ‘val’ PatDef