Implemented AppliedTerm, a type representing a term-level application. AppliedTerms are currently only introduced when they are stable, that is, when both the function and the arguments are. For this purpose, methods on primitive value classes are now marked stable. Also adds new syntax for singleton types -- type trees written { expr } are translated to the singleton type of expr, provided that type is stable.

Author: gsps

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

@@ -547,6 +547,17 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             false
         }
         compareTypeBounds
+      case tp2: AppliedTermRef =>
+        def compareAppliedTerm = tp1 match {
+          case _ if !ctx.phase.isTyper =>
+            // Need to be more permissive when checking later phases, applications may have been rewritten
+            isSubType(tp1, tp2.resType)
+          case tp1: AppliedTermRef =>
+            tp1.args.size == tp2.args.size && isSubType(tp1.fn, tp2.fn) &&
+              (tp1.args zip tp2.args).forall(t => isSubType(t._1, t._2))
+          case _ => fourthTry
+        }
+        compareAppliedTerm
       case ClassInfo(pre2, cls2, _, _, _) =>
         def compareClassInfo = tp1 match {
           case ClassInfo(pre1, cls1, _, _, _) =>

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

@@ -148,6 +148,7 @@ object Types {
     /** Does this type denote a stable reference (i.e. singleton type)? */
     final def isStable(implicit ctx: Context): Boolean = stripTypeVar match {
       case tp: TermRef => tp.termSymbol.isStable && tp.prefix.isStable || tp.info.isStable
+      case tp: AppliedTermRef => tp.fn.isStable && tp.args.forall(_.isStable)
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
@@ -282,14 +283,14 @@ object Types {
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
      */
-    def isVarArgsMethod(implicit ctx: Context): Boolean = stripPoly match {
+    def isVarArgsMethod(implicit ctx: Context): Boolean = stripMethodPrefix match {
       case mt: MethodType => mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam
       case _ => false
     }
 
     /** Is this the type of a method with a leading empty parameter list?
      */
-    def isNullaryMethod(implicit ctx: Context): Boolean = stripPoly match {
+    def isNullaryMethod(implicit ctx: Context): Boolean = stripMethodPrefix match {
       case MethodType(Nil) => true
       case _ => false
     }
@@ -899,9 +900,10 @@ object Types {
       */
     def stripAnnots(implicit ctx: Context): Type = this
 
-    /** Strip PolyType prefix */
-    def stripPoly(implicit ctx: Context): Type = this match {
-      case tp: PolyType => tp.resType.stripPoly
+    /** Strip PolyType and AppliedTermRef prefix */
+    def stripMethodPrefix(implicit ctx: Context): Type = this match {
+      case tp: PolyType => tp.resType.stripMethodPrefix
+      case tp: AppliedTermRef => tp.resType.stripMethodPrefix
       case _ => this
     }
 
@@ -1212,26 +1214,26 @@ object Types {
     }
 
     /** The parameter types of a PolyType or MethodType, Empty list for others */
-    final def paramInfoss(implicit ctx: Context): List[List[Type]] = stripPoly match {
+    final def paramInfoss(implicit ctx: Context): List[List[Type]] = stripMethodPrefix match {
       case mt: MethodType => mt.paramInfos :: mt.resultType.paramInfoss
       case _ => Nil
     }
 
     /** The parameter names of a PolyType or MethodType, Empty list for others */
-    final def paramNamess(implicit ctx: Context): List[List[TermName]] = stripPoly match {
+    final def paramNamess(implicit ctx: Context): List[List[TermName]] = stripMethodPrefix match {
       case mt: MethodType => mt.paramNames :: mt.resultType.paramNamess
       case _ => Nil
     }
 
 
     /** The parameter types in the first parameter section of a generic type or MethodType, Empty list for others */
-    final def firstParamTypes(implicit ctx: Context): List[Type] = stripPoly match {
+    final def firstParamTypes(implicit ctx: Context): List[Type] = stripMethodPrefix match {
       case mt: MethodType => mt.paramInfos
       case _ => Nil
     }
 
     /** Is this either not a method at all, or a parameterless method? */
-    final def isParameterless(implicit ctx: Context): Boolean = stripPoly match {
+    final def isParameterless(implicit ctx: Context): Boolean = stripMethodPrefix match {
       case mt: MethodType => false
       case _ => true
     }
@@ -1242,7 +1244,7 @@ object Types {
     /** The final result type of a PolyType, MethodType, or ExprType, after skipping
      *  all parameter sections, the type itself for all others.
      */
-    def finalResultType(implicit ctx: Context): Type = resultType.stripPoly match {
+    def finalResultType(implicit ctx: Context): Type = resultType.stripMethodPrefix match {
       case mt: MethodType => mt.resultType.finalResultType
       case _ => resultType
     }
@@ -2171,6 +2173,55 @@ object Types {
       apply(prefix, if (denot.symbol.exists) denot.symbol.asType else name).withDenot(denot)
   }
 
+  // --- AppliedTermRef ---------------------------------------------------------------------
+
+  /** An opaque representation of a term-level application. **/
+  abstract case class AppliedTermRef(fn: /*TermRef | AppliedTermRef*/ SingletonType, args: List[Type])
+    extends CachedProxyType with SingletonType
+  {
+    protected[this] var myResType: Type = _
+    def resType(implicit ctx: Context): Type = {
+      if (myResType == null)
+        // FIXME(gsps): Sometimes TermRef(TermParamRef(<fun>, 1), +) might not have a denot, e.g., when calling
+        //   def add[X<:Int, Y<:Int, Z<:Int](x: X, y: Y, z: {x + y}): z.type = z
+        fn.widen match {
+          case methTpe: MethodType => myResType = ctx.typer.applicationResultType(methTpe, args)
+        }
+      myResType
+    }
+
+    def underlying(implicit ctx: Context): Type = resType
+
+    def derivedAppliedTerm(fn: Type, args: List[Type])(implicit ctx: Context): Type =
+      if ((this.fn eq fn) && (this.args eq args)) this
+      else AppliedTermRef(fn, args)
+
+    override def computeHash(bs: Binders) = doHash(bs, fn, args)
+
+    override def eql(that: Type) = that match {
+      case that: AppliedTermRef => (this.fn eq that.fn) && this.args.eqElements(that.args)
+      case _ => false
+    }
+  }
+
+  final class CachedAppliedTermRef(fn: SingletonType, args: List[Type]) extends AppliedTermRef(fn, args)
+
+  object AppliedTermRef {
+    def apply(fn: Type, args: List[Type])(implicit ctx: Context): Type = {
+      assertUnerased()
+      fn.dealias match {
+        case fn: TermRef => unique(new CachedAppliedTermRef(fn, args))
+        case fn: AppliedTermRef => unique(new CachedAppliedTermRef(fn, args))
+        case _ =>
+          fn.widenDealias match {
+            case methTpe: MethodType => ctx.typer.applicationResultType(methTpe, args)  // TODO(gsps): Check length?
+            case _: WildcardType => WildcardType
+            case tp => throw new AssertionError(i"Don't know how to apply $tp.")
+          }
+      }
+    }
+  }
+
   // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------
 
   /** The type cls.this
@@ -3791,7 +3842,7 @@ object Types {
   object SAMType {
     def zeroParamClass(tp: Type)(implicit ctx: Context): Type = tp match {
       case tp: ClassInfo =>
-        def zeroParams(tp: Type): Boolean = tp.stripPoly match {
+        def zeroParams(tp: Type): Boolean = tp.stripMethodPrefix match {
           case mt: MethodType => mt.paramInfos.isEmpty && !mt.resultType.isInstanceOf[MethodType]
           case et: ExprType => true
           case _ => false
@@ -3877,6 +3928,8 @@ object Types {
       tp.derivedSuperType(thistp, supertp)
     protected def derivedAppliedType(tp: AppliedType, tycon: Type, args: List[Type]): Type =
       tp.derivedAppliedType(tycon, args)
+    protected def derivedAppliedTerm(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
+      tp.derivedAppliedTerm(fn, args)
     protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type): Type =
       tp.derivedAndType(tp1, tp2)
     protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type): Type =
@@ -3932,6 +3985,9 @@ object Types {
           }
           derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tp.typeParams))
 
+        case tp: AppliedTermRef =>
+          derivedAppliedTerm(tp, this(tp.fn), tp.args.mapConserve(this))
+
         case tp: RefinedType =>
           derivedRefinedType(tp, this(tp.parent), this(tp.refinedInfo))
 
@@ -4228,6 +4284,25 @@ object Types {
           else tp.derivedAppliedType(tycon, args)
       }
 
+    override protected def derivedAppliedTerm(tp: AppliedTermRef, fn: Type, args: List[Type]): Type =
+      fn match {
+        case Range(fnLo, fnHi) =>
+          range(derivedAppliedTerm(tp, fnLo, args), derivedAppliedTerm(tp, fnHi, args))
+        case _ =>
+          if (fn.isBottomType) {
+            fn
+          } else if (args.exists(isRange)) {
+            val loBuf, hiBuf = new mutable.ListBuffer[Type]
+            args foreach {
+              case Range(lo, hi) => loBuf += lo; hiBuf += hi
+              case arg => loBuf += arg; hiBuf += arg
+            }
+            range(tp.derivedAppliedTerm(fn, loBuf.toList), tp.derivedAppliedTerm(fn, hiBuf.toList))
+          } else {
+            tp.derivedAppliedTerm(fn, args)
+          }
+      }
+
     override protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type) =
       if (isRange(tp1) || isRange(tp2)) range(lower(tp1) & lower(tp2), upper(tp1) & upper(tp2))
       else tp.derivedAndType(tp1, tp2)
@@ -4318,6 +4393,9 @@ object Types {
           }
         foldArgs(this(x, tycon), tp.typeParams, args)
 
+      case tp: AppliedTermRef =>
+        foldOver(this(x, tp.fn), tp.args)
+
       case _: BoundType | _: ThisType => x
 
       case tp: LambdaType =>

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -400,6 +400,7 @@ object TastyFormat {
   final val ANNOTATION = 173
   final val TERMREFin = 174
   final val TYPEREFin = 175
+  final val APPLIEDTERM = 176
   final val HOLE = 255
 
   final val firstSimpleTreeTag = UNITconst

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -157,6 +157,9 @@ class TreePickler(pickler: TastyPickler) {
     case AppliedType(tycon, args) =>
       writeByte(APPLIEDtype)
       withLength { pickleType(tycon); args.foreach(pickleType(_)) }
+    case AppliedTermRef(fn, args) =>
+      writeByte(APPLIEDTERM)
+      withLength { pickleType(fn); args.foreach(pickleType(_)) }
     case ConstantType(value) =>
       pickleConstant(value)
     case tpe: NamedType =>

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -272,6 +272,8 @@ class TreeUnpickler(reader: TastyReader,
                 // Eta expansion of the latter puts readType() out of the expression.
             case APPLIEDtype =>
               readType().appliedTo(until(end)(readType()))
+            case APPLIEDTERM =>
+              AppliedTermRef(readType(), until(end)(readType()))
             case TYPEBOUNDS =>
               TypeBounds(readType(), readType())
             case ANNOTATEDtype =>

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -423,6 +423,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       }
     }
 
+    // TODO(gsps): This is a hack to mark certain primitive methods as stable.
+    //  In the future such primitive methods should be pickled with the Stable flag set.
+    def markPrimitiveStable(owner: Symbol, name: Name, flags: FlagSet): FlagSet =
+      if (defn.ScalaValueClasses().contains(owner)) flags | Stable
+      else flags
+
     tag match {
       case NONEsym => return NoSymbol
       case EXTref | EXTMODCLASSref => return readExtSymbol()
@@ -447,6 +453,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       name =
         if (name == nme.TRAIT_CONSTRUCTOR) nme.CONSTRUCTOR
         else name.asTermName.unmangle(Scala2MethodNameKinds)
+      flags = markPrimitiveStable(owner, name, flags)
     }
     if ((flags is Scala2ExpandedName)) {
       name = name.unmangle(ExpandedName)

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

@@ -863,7 +863,7 @@ object Parsers {
           makeTupleOrParens(inParens(argTypes(namedOK = false, wildOK = true)))
         }
       else if (in.token == LBRACE)
-        atPos(in.offset) { RefinedTypeTree(EmptyTree, refinement()) }
+        atPos(in.offset) { inBraces(emptyRefinementOrSingletonExpr()) }
       else if (isSimpleLiteral) { SingletonTypeTree(literal()) }
       else if (in.token == USCORE) {
         val start = in.skipToken()
@@ -877,6 +877,11 @@ object Parsers {
       }
     }
 
+    def emptyRefinementOrSingletonExpr(): Tree = {
+      if (!isStatSeqEnd && !isDclIntro) SingletonTypeTree(postfixExpr())
+      else RefinedTypeTree(EmptyTree, refineStatSeq())
+    }
+
     val handleSingletonType: Tree => Tree = t =>
       if (in.token == TYPE) {
         in.nextToken()

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

@@ -60,6 +60,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
           homogenize(tp.ref)
         case AppliedType(tycon, args) =>
           tycon.dealias.appliedTo(args)
+        case tp: AppliedTermRef =>
+          homogenize(tp.underlying)
         case _ =>
           tp
       }
@@ -141,6 +143,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
         ParamRefNameString(tp) ~ ".type"
       case tp: TypeParamRef =>
         ParamRefNameString(tp) ~ lambdaHash(tp.binder)
+      case tp: AppliedTermRef =>
+        toTextRef(tp) ~ ".type"
       case tp: SingletonType =>
         toTextLocal(tp.underlying) ~ "(" ~ toTextRef(tp) ~ ")"
       case AppliedType(tycon, args) =>
@@ -260,6 +264,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
         toTextPrefix(tp.prefix) ~ selectionString(tp)
       case tp: ThisType =>
         nameString(tp.cls) + ".this"
+      case AppliedTermRef(fn, args) =>
+        (toTextRef(fn) ~ "(" ~ Text(args map argText, ", ") ~ ")").close
       case SuperType(thistpe: SingletonType, _) =>
         toTextRef(thistpe).map(_.replaceAll("""\bthis$""", "super"))
       case SuperType(thistpe, _) =>

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -394,6 +394,9 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         val apiTycon = simpleType(tycon)
         val apiArgs = args.map(processArg)
         new api.Parameterized(apiTycon, apiArgs.toArray)
+      // TODO(gsps): Implement sbt-api translation for AppliedTermRef
+      // case tp: AppliedTermRef =>
+      //   ???
       case tl: TypeLambda =>
         val apiTparams = tl.typeParams.map(apiTypeParameter)
         val apiRes = apiType(tl.resType)

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

@@ -1345,7 +1345,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           case x => x
         }
 
-        def sizeFits(alt: TermRef, tp: Type): Boolean = tp.stripPoly match {
+        def sizeFits(alt: TermRef, tp: Type): Boolean = tp.stripMethodPrefix match {
           case tp: MethodType =>
             val ptypes = tp.paramInfos
             val numParams = ptypes.length

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

@@ -120,7 +120,7 @@ object Implicits {
             !(isFunctionInS2 || isImplicitConverter || isConforms)
         }
 
-        def discardForValueType(tpw: Type): Boolean = tpw.stripPoly match {
+        def discardForValueType(tpw: Type): Boolean = tpw.stripMethodPrefix match {
           case tpw: MethodType => !tpw.isImplicitMethod
           case _ => false
         }

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

@@ -358,14 +358,22 @@ trait TypeAssigner {
       tp
     }
 
+  def applicationResultType(methTp: MethodType, args: List[Type])(implicit ctx: Context): Type =
+    if (methTp.isResultDependent) safeSubstParams(methTp.resultType, methTp.paramRefs, args)
+    else methTp.resultType
+
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
-    val ownType = fn.tpe.widen match {
-      case fntpe: MethodType =>
-        if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping)
-          if (fntpe.isResultDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes)
-          else fntpe.resultType
-        else
-          errorType(i"wrong number of arguments at ${ctx.phase.prev} for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.pos)
+    val fnTpe = fn.tpe
+    val ownType = fnTpe.widen match {
+      case methTp: MethodType =>
+        if (sameLength(methTp.paramInfos, args) || ctx.phase.prev.relaxedTyping) {
+          val argTpes = args.tpes
+          if (!ctx.erasedTypes && fnTpe.isStable && argTpes.forall(_.isStable))
+            AppliedTermRef(fnTpe, argTpes)
+          else
+            applicationResultType(methTp, argTpes)
+        } else
+          errorType(i"wrong number of arguments at ${ctx.phase.prev} for $methTp: $fnTpe, expected: ${methTp.paramInfos.length}, found: ${args.length}", tree.pos)
       case t =>
         errorType(err.takesNoParamsStr(fn, ""), tree.pos)
     }

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

@@ -1444,7 +1444,7 @@ class Typer extends Namer
      *  @param psym  Its type symbol
      *  @param cinfo The info of its constructor
      */
-    def maybeCall(ref: Tree, psym: Symbol, cinfo: Type): Tree = cinfo.stripPoly match {
+    def maybeCall(ref: Tree, psym: Symbol, cinfo: Type): Tree = cinfo.stripMethodPrefix match {
       case cinfo @ MethodType(Nil) if cinfo.resultType.isImplicitMethod =>
         val icall = New(ref).select(nme.CONSTRUCTOR).appliedToNone
         typedExpr(untpd.TypedSplice(icall))(superCtx)