Parse type/singleton applications

Author: odersky

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

@@ -192,7 +192,9 @@ object Parsers {
 
     def isIdent = in.isIdent
     def isIdent(name: Name) = in.isIdent(name)
-    def isSimpleLiteral = simpleLiteralTokens contains in.token
+    def isSimpleLiteral =
+      simpleLiteralTokens.contains(in.token)
+      || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
     def isLiteral = literalTokens contains in.token
     def isNumericLit = numericLitTokens contains in.token
     def isTemplateIntro = templateIntroTokens contains in.token
@@ -1100,18 +1102,42 @@ object Parsers {
     */
     def qualId(): Tree = dotSelectors(termIdent())
 
-    /** SimpleExpr    ::= literal
-     *                  | 'id | 'this | 'true | 'false | 'null
-     *                  | null
+    /** Singleton    ::=  SimpleRef
+     *                 |  SimpleLiteral
+     *                 |  Singleton ‘.’ id
+     */
+    def singleton(): Tree =
+      if isSimpleLiteral then simpleLiteral()
+      else dotSelectors(simpleRef())
+
+    /** SimpleLiteral     ::=  [‘-’] integerLiteral
+     *                      |  [‘-’] floatingPointLiteral
+     *                      |  booleanLiteral
+     *                      |  characterLiteral
+     *                      |  stringLiteral
+     */
+    def simpleLiteral(): Tree =
+      if isIdent(nme.raw.MINUS) then
+        val start = in.offset
+        in.nextToken()
+        literal(negOffset = start, inTypeOrSingleton = true)
+      else
+        literal(inTypeOrSingleton = true)
+
+    /** Literal           ::=  SimpleLiteral
+     *                      |  processedStringLiteral
+     *                      |  symbolLiteral
+     *                      |  ‘null’
+     *
      *  @param negOffset   The offset of a preceding `-' sign, if any.
-     *                     If the literal is not negated, negOffset = in.offset.
+     *                     If the literal is not negated, negOffset == in.offset.
      */
-    def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inType: Boolean = false, inStringInterpolation: Boolean = false): Tree = {
+    def literal(negOffset: Int = in.offset, inPattern: Boolean = false, inTypeOrSingleton: Boolean = false, inStringInterpolation: Boolean = false): Tree = {
       def literalOf(token: Token): Tree = {
         val isNegated = negOffset < in.offset
         def digits0 = in.removeNumberSeparators(in.strVal)
         def digits = if (isNegated) "-" + digits0 else digits0
-        if (!inType)
+        if !inTypeOrSingleton then
           token match {
             case INTLIT  => return Number(digits, NumberKind.Whole(in.base))
             case DECILIT => return Number(digits, NumberKind.Decimal)
@@ -1554,15 +1580,12 @@ object Parsers {
 
     /**  SimpleType      ::=  SimpleLiteral
      *                     |  ‘?’ SubtypeBounds
-     *                     |  SimpleType1
+     *                     |  SimpleType1 { ‘(’ Singletons ‘)’ }
+     *   Singletons      ::=  Singleton {‘,’ Singleton}
      */
     def simpleType(): Tree =
       if isSimpleLiteral then
-        SingletonTypeTree(literal(inType = true))
-      else if isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token) then
-        val start = in.offset
-        in.nextToken()
-        SingletonTypeTree(literal(negOffset = start, inType = true))
+        SingletonTypeTree(simpleLiteral())
       else if in.token == USCORE then
         if sourceVersion.isAtLeast(`3.1`) then
           deprecationWarning(em"`_` is deprecated for wildcard arguments of types: use `?` instead")
@@ -1575,7 +1598,11 @@ object Parsers {
       else if isIdent(nme.*) && ctx.settings.YkindProjector.value then
         typeIdent()
       else
-        simpleType1()
+        def singletonArgs(t: Tree): Tree =
+          if in.token == LPAREN
+          then singletonArgs(AppliedTypeTree(t, inParens(commaSeparated(singleton))))
+          else t
+        singletonArgs(simpleType1())
 
     /** SimpleType1      ::=  id
      *                     |  Singleton `.' id

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -477,8 +477,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           changePrec(OrTypePrec) { toText(args(0)) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(args(1)) } }
         else if (tpt.symbol == defn.andType && args.length == 2)
           changePrec(AndTypePrec) { toText(args(0)) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(args(1)) } }
-        else
-          toTextLocal(tpt) ~ "[" ~ Text(args map argText, ", ") ~ "]"
+        else args match
+          case arg :: _ if arg.isTerm =>
+            toTextLocal(tpt) ~ "(" ~ Text(args.map(argText), ", ") ~ ")"
+          case _ =>
+            toTextLocal(tpt) ~ "[" ~ Text(args.map(argText), ", ") ~ "]"
       case LambdaTypeTree(tparams, body) =>
         changePrec(GlobalPrec) {
           tparamsText(tparams) ~ " =>> " ~ toText(body)

docs/docs/internals/syntax.md

@@ -139,13 +139,15 @@ ClassQualifier    ::=  ‘[’ id ‘]’
 ```ebnf
 Type              ::=  FunType
                     |  HkTypeParamClause ‘=>>’ Type                             TypeLambda(ps, t)
+                    |  ‘(’ TypedFunParams ‘)’ ‘=>>’ Type                        TypeLambda(ps, t)
                     |  MatchType
                     |  InfixType
 FunType           ::=  FunArgTypes (‘=>’ | ‘?=>’) Type                          Function(ts, t)
                     |  HKTypeParamClause '=>' Type                              PolyFunction(ps, t)
 FunArgTypes       ::=  InfixType
                     |  ‘(’ [ FunArgType {‘,’ FunArgType } ] ‘)’
-                    |  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
+                    |  ‘(’ TypedFunParams ‘)’
+TypedFunParams    ::=  TypedFunParam {‘,’ TypedFunParam }
 TypedFunParam     ::=  id ‘:’ Type
 MatchType         ::=  InfixType `match` ‘{’ TypeCaseClauses ‘}’
 InfixType         ::=  RefinedType {id [nl] RefinedType}                        InfixOp(t1, op, t2)
@@ -155,8 +157,7 @@ AnnotType         ::=  SimpleType {Annotation}
 
 SimpleType        ::=  SimpleLiteral                                            SingletonTypeTree(l)
                     |  ‘?’ SubtypeBounds
-                    |  SimpleType ‘(’ Singletons ‘)’
-                    |  SimpleType1
+                    |  SimpleType1 { ‘(’ Singletons ‘)’ }
 SimpleType1       ::=  id                                                       Ident(name)
                     |  Singleton ‘.’ id                                         Select(t, name)
                     |  Singleton ‘.’ ‘type’                                     SingletonTypeTree(p)
@@ -166,6 +167,7 @@ SimpleType1       ::=  id
                     |  SimpleType1 TypeArgs                                     AppliedTypeTree(t, args)
                     |  SimpleType1 ‘#’ id                                       Select(t, name)
 Singleton         ::=  SimpleRef
+                    |  SimpleLiteral
                     |  Singleton ‘.’ id
 -- not yet          |  Singleton ‘(’ Singletons ‘)’
 -- not yet          |  Singleton ‘[’ ArgTypes ‘]’