Implement collection literals

Author: odersky

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

@@ -563,7 +563,7 @@ class Definitions {
     @tu lazy val Seq_lengthCompare: Symbol = SeqClass.requiredMethod(nme.lengthCompare, List(IntType))
     @tu lazy val Seq_length       : Symbol = SeqClass.requiredMethod(nme.length)
     @tu lazy val Seq_toSeq        : Symbol = SeqClass.requiredMethod(nme.toSeq)
-
+  @tu lazy val MapModule: Symbol           = requiredModule("scala.collection.immutable.Map")
 
   @tu lazy val StringOps: Symbol = requiredClass("scala.collection.StringOps")
     @tu lazy val StringOps_format: Symbol  = StringOps.requiredMethod(nme.format)
@@ -582,6 +582,9 @@ class Definitions {
   @tu lazy val IArrayModule: Symbol = requiredModule("scala.IArray")
   def IArrayModuleClass: Symbol = IArrayModule.moduleClass
 
+  @tu lazy val ExpressibleAsCollectionLiteralClass: ClassSymbol = requiredClass("scala.compiletime.ExpressibleAsCollectionLiteral")
+    @tu lazy val ExpressibleACL_fromLiteral: Symbol = ExpressibleAsCollectionLiteralClass.requiredMethod("fromLiteral")
+
   @tu lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
   def UnitClass(using Context): ClassSymbol = UnitType.symbol.asClass
   def UnitModuleClass(using Context): Symbol = UnitType.symbol.asClass.linkedClass

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

@@ -500,6 +500,7 @@ object StdNames {
     val foreach: N              = "foreach"
     val format: N               = "format"
     val fromDigits: N           = "fromDigits"
+    val fromLiteral: N          = "fromLiteral"
     val fromProduct: N          = "fromProduct"
     val genericArrayOps: N      = "genericArrayOps"
     val genericClass: N         = "genericClass"

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

@@ -4913,7 +4913,7 @@ object Types extends TypeUtils {
     /** The state owning the variable. This is at first `creatorState`, but it can
      *  be changed to an enclosing state on a commit.
      */
-    private[core] var owningState: WeakReference[TyperState] | Null =
+    private[dotc] var owningState: WeakReference[TyperState] | Null =
       if (creatorState == null) null else new WeakReference(creatorState)
 
     /** The nesting level of this type variable in the current typer state. This is usually

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

@@ -2390,7 +2390,7 @@ object Parsers {
       in.token match
         case IMPLICIT =>
           closure(start, location, modifiers(BitSet(IMPLICIT)))
-        case LBRACKET =>
+        case LBRACKET if followingIsArrow() =>
           val start = in.offset
           val tparams = typeParamClause(ParamOwner.Type)
           val arrowOffset = accept(ARROW)
@@ -2710,6 +2710,7 @@ object Parsers {
      *                 |  xmlLiteral
      *                 |  SimpleRef
      *                 |  `(` [ExprsInParens] `)`
+     *                 |  `[` ExprsInBrackets `]`
      *                 |  SimpleExpr `.` id
      *                 |  SimpleExpr `.` MatchClause
      *                 |  SimpleExpr (TypeArgs | NamedTypeArgs)
@@ -2745,6 +2746,9 @@ object Parsers {
         case LBRACE | INDENT =>
           canApply = false
           blockExpr()
+        case LBRACKET =>
+          inBrackets:
+            SeqLiteral(exprsInBrackets(), TypeTree())
         case QUOTE =>
           quote(location.inPattern)
         case NEW =>
@@ -2840,6 +2844,12 @@ object Parsers {
         commaSeparatedRest(exprOrBinding(), exprOrBinding)
       }
 
+    /**  ExprsInBrackets   ::=  ExprInParens {`,' ExprInParens} */
+    def exprsInBrackets(): List[Tree] =
+      if in.token == RBRACKET then Nil
+      else in.currentRegion.withCommasExpected:
+        commaSeparatedRest(exprInParens(), exprInParens)
+
     /** ParArgumentExprs ::= `(' [‘using’] [ExprsInParens] `)'
      *                    |  `(' [ExprsInParens `,'] PostfixExpr `*' ')'
      */

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -891,7 +891,7 @@ object Erasure {
     // The following four methods take as the proto-type the erasure of the pre-existing type,
     // if the original proto-type is not a value type.
     // This makes all branches be adapted to the correct type.
-    override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral =
+    override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): Tree =
       super.typedSeqLiteral(tree, erasure(tree.typeOpt))
         // proto type of typed seq literal is original type;
 

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -443,10 +443,12 @@ object Implicits:
   extends SearchResult with RefAndLevel with Showable:
     final def found = ref :: Nil
 
+  def isAmbiguousGiven(tree: Tree) = tree.tpe.isInstanceOf[AmbiguousImplicits | TooUnspecific]
+
   /** A failed search */
   case class SearchFailure(tree: Tree) extends SearchResult {
     require(tree.tpe.isInstanceOf[SearchFailureType], s"unexpected type for ${tree}")
-    final def isAmbiguous: Boolean = tree.tpe.isInstanceOf[AmbiguousImplicits | TooUnspecific]
+    final def isAmbiguous: Boolean = isAmbiguousGiven(tree)
     final def reason: SearchFailureType = tree.tpe.asInstanceOf[SearchFailureType]
     final def found = tree.tpe match
       case tpe: AmbiguousImplicits => tpe.alt1.ref :: tpe.alt2.ref :: Nil

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -58,11 +58,13 @@ object Inferencing {
    *  The method is called to instantiate type variables before an implicit search.
    */
   def instantiateSelected(tp: Type, tvars: List[Type])(using Context): Unit =
-    if (tvars.nonEmpty)
-      IsFullyDefinedAccumulator(
+    if tvars.nonEmpty then instantiateSelected(tp, tvars.contains, minimize = true)
+
+  def instantiateSelected(tp: Type, cond: TypeVar => Boolean, minimize: Boolean)(using Context): Unit =
+    IsFullyDefinedAccumulator(
         new ForceDegree.Value(IfBottom.flip):
-          override def appliesTo(tvar: TypeVar) = tvars.contains(tvar),
-        minimizeSelected = true
+          override def appliesTo(tvar: TypeVar) = cond(tvar),
+        minimizeSelected = minimize
       ).process(tp)
 
   /** Instantiate any type variables in `tp` whose bounds contain a reference to

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

@@ -2375,7 +2375,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             Annotation(defn.RequiresCapabilityAnnot, cap, tree.span))))
     else res
 
-  def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral = {
+  def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): Tree =
     val elemProto = pt.stripNull().elemType match {
       case NoType => WildcardType
       case bounds: TypeBounds => WildcardType(bounds)
@@ -2385,25 +2385,78 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def assign(elems1: List[Tree], elemtpt1: Tree) =
       assignType(cpy.SeqLiteral(tree)(elems1, elemtpt1), elems1, elemtpt1)
 
-    if (!tree.elemtpt.isEmpty) {
+    // Seq literal used in varargs: elem type is given
+    def varargSeqLiteral =
       val elemtpt1 = typed(tree.elemtpt, elemProto)
       val elems1 = tree.elems.mapconserve(typed(_, elemtpt1.tpe))
       assign(elems1, elemtpt1)
-    }
-    else {
-      assert(tree.isInstanceOf[Trees.JavaSeqLiteral[?]])
+
+    // Seq literal used in Java annotations: elem type needs to be computed
+    def javaSeqLiteral =
       val elems1 = tree.elems.mapconserve(typed(_, elemProto))
       val elemtptType =
-        if (isFullyDefined(elemProto, ForceDegree.none))
+        if isFullyDefined(elemProto, ForceDegree.none) then
           elemProto
-        else if (tree.elems.isEmpty && tree.isInstanceOf[Trees.JavaSeqLiteral[?]])
+        else if tree.elems.isEmpty then
           defn.ObjectType // generic empty Java varargs are of type Object[]
         else
           TypeComparer.lub(elems1.tpes)
       val elemtpt1 = typed(tree.elemtpt, elemtptType)
       assign(elems1, elemtpt1)
-    }
-  }
+
+    // Stand-alone collection literal [x1, ..., xN]
+    def collectionLiteral =
+      def isArrow(tree: untpd.Tree) = tree match
+        case untpd.InfixOp(_, Ident(nme.PUREARROW), _) => true
+        case _ => false
+
+      // The default maker if no typeclass is searched or found
+      def defaultMaker =
+        if tree.elems.nonEmpty && tree.elems.forall(isArrow)
+        then untpd.ref(defn.MapModule)
+        else untpd.ref(defn.SeqModule)
+
+      // We construct and typecheck a term `maker(tree.elems)`, where `maker`
+      // is either a given instance of type ExpressibleAsCollectionLiteralClass
+      // or a default instance. The default instance is either Seq or Map,
+      // depending on the forms of `tree.elems`. We search for a type class if
+      // the expected type is a value type that is not an uninstantiated type variable.
+      val maker = pt match
+        case pt: TypeVar if !pt.isInstantiated =>
+          defaultMaker
+        case pt: ValueType =>
+          val tc = defn.ExpressibleAsCollectionLiteralClass.typeRef.appliedTo(pt)
+          val nestedCtx = ctx.fresh.setNewTyperState()
+          val maker = inContext(nestedCtx):
+            // Find given instance `witness` of type `ExpressibleAsCollectionLiteral[<pt>]`
+            val witness = inferImplicitArg(tc, tree.span.startPos)
+            if witness.tpe.isInstanceOf[SearchFailureType] then
+              val msg = missingArgMsg(witness, pt, "")
+              if isAmbiguousGiven(witness) then report.error(msg, tree.srcPos)
+              else typr.println(i"failed collection literal witness: ${msg.toString}")
+              defaultMaker
+            else
+              // Instantiate local type variables in witness.tpe, so that nested
+              // SeqLiterals don't get typed as default Seq due to first case above
+              def isLocal(tv: TypeVar) =
+                val state = tv.owningState
+                state != null && (state.get eq ctx.typerState)
+              instantiateSelected(witness.tpe, isLocal, minimize = false)
+              // Continue with typing `witness.fromLiteral` as the constructor
+              untpd.TypedSplice(witness.select(nme.fromLiteral))
+          nestedCtx.typerState.commit()
+          maker
+        case _ =>
+          defaultMaker
+      typed(
+        untpd.Apply(maker, tree.elems).withSpan(tree.span)
+          .showing(i"typed collection literal $tree ---> $result", typr)
+        , pt)
+
+    if !tree.elemtpt.isEmpty then varargSeqLiteral
+    else if tree.isInstanceOf[Trees.JavaSeqLiteral[?]] then javaSeqLiteral
+    else collectionLiteral
+  end typedSeqLiteral
 
   def typedInlined(tree: untpd.Inlined, pt: Type)(using Context): Tree =
     throw new UnsupportedOperationException("cannot type check a Inlined node")

docs/_docs/internals/syntax.md

@@ -278,6 +278,7 @@ SimpleExpr        ::=  SimpleRef
                     |  ‘new’ ConstrApp {‘with’ ConstrApp} [TemplateBody]        New(constr | templ)
                     |  ‘new’ TemplateBody
                     |  ‘(’ ExprsInParens ‘)’                                    Parens(exprs)
+                    |  ‘[’ ExprInBrackets ‘)’                                   SeqLiteral(exprs, TypeTree())
                     |  SimpleExpr ‘.’ id                                        Select(expr, id)
                     |  SimpleExpr ‘.’ MatchClause
                     |  SimpleExpr TypeArgs                                      TypeApply(expr, args)
@@ -299,6 +300,7 @@ TypeSplice        ::= spliceId
                     |  ‘$’ ‘{’ Pattern ‘}’                                      -- when inside quoted type pattern -- deprecated syntax
 ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
                     |  NamedExprInParens {‘,’ NamedExprInParens}
+ExprsInBrackets   ::=  ExprInParens {‘,’ ExprInParens}
 ExprInParens      ::=  PostfixExpr ‘:’ Type                                     -- normal Expr allows only RefinedType here
                     |  Expr
 NamedExprInParens ::=  id '=' ExprInParens

library/src/scala/compiletime/ExpressibleAsCollectionLiteral.scala

@@ -0,0 +1,56 @@
+package scala.compiletime
+import reflect.ClassTag
+
+// This is in compiletime since it is an inline type class. Another
+// possibility would be to put it in `scala.collection`
+
+/** A typeclass that supports creating collection-like data from
+ *  collection literals `[x1,...,xN]`.
+ */
+trait ExpressibleAsCollectionLiteral[+Coll]:
+
+  /** The element type of the created collection */
+  type Elem
+
+  /** The inline method that creates the collection */
+  inline def fromLiteral(inline xs: Elem*): Coll
+
+object ExpressibleAsCollectionLiteral:
+
+  // Some instances for standard collections. It would be good to have a method
+  // that works for all collections in stdlib. But to do that I believe we either
+  // have to put a given instance in Factory in stdlib, or write some macro
+  // method here. I have not found a straightforward way to build a collection
+  // of type `C` is all we know is the type.
+
+  given seqFromLiteral: [T] => ExpressibleAsCollectionLiteral[collection.Seq[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*): Seq[T] = Seq(xs*)
+
+  given mutableSeqFromLiteral: [T] => ExpressibleAsCollectionLiteral[collection.mutable.Seq[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = collection.mutable.Seq(xs*)
+
+  given immutableSeqFromLiteral: [T] => ExpressibleAsCollectionLiteral[collection.immutable.Seq[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = collection.immutable.Seq(xs*)
+
+  given vectorFromLiteral: [T] => ExpressibleAsCollectionLiteral[Vector[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = Vector[Elem](xs*)
+
+  given listFromLiteral: [T] => ExpressibleAsCollectionLiteral[List[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = List(xs*)
+
+  given arrayFromLiteral: [T: ClassTag] => ExpressibleAsCollectionLiteral[Array[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = Array(xs*)
+
+  given iarrayFromLiteral: [T: ClassTag] => ExpressibleAsCollectionLiteral[IArray[T]]:
+    type Elem = T
+    inline def fromLiteral(inline xs: T*) = IArray(xs*)
+
+  given bitsetFromLiteral: ExpressibleAsCollectionLiteral[collection.immutable.BitSet]:
+    type Elem = Int
+    inline def fromLiteral(inline xs: Int*) = collection.immutable.BitSet(xs*)