Add singleton string concatenation

This commit serves as a proof-of-concept of "overloaded" singleton ops.
`+` is already addition, so adding concatenation requires "overloading"
the `+` op. Scala does not support overloaded type aliases, so we must
have two + types in different objects. However:

- unqualified references (`+`) can be ambiguous (`int.+` or `string.+`)
- qualified types (e.g. `int.+`) cannot be used infix

The solution is to have a top-level `+` match type that redirects to
the qualified `int.+` or `string.+`. These are kept private, as an
implementation detail. The top-level match type is not considered as a
compiletime applied type, as we cannot do constant folding before the
match type has been applied.

Author: MaximeKjaer

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

@@ -903,15 +903,19 @@ class Definitions {
 
   private val compiletimePackageTypes: Set[Name] = Set(
     tpnme.Equals, tpnme.NotEquals,
-    tpnme.Plus, tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
+    tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
     tpnme.Lt, tpnme.Gt, tpnme.Ge, tpnme.Le,
     tpnme.Abs, tpnme.Negate, tpnme.Min, tpnme.Max, tpnme.ToString,
     tpnme.Not, tpnme.Xor, tpnme.And, tpnme.Or
   )
+  private val compiletimePackageIntTypes: Set[Name] = Set(tpnme.Plus)
+  private val compiletimePackageStringTypes: Set[Name] = Set(tpnme.Plus)
 
   final def isCompiletimeAppliedType(sym: Symbol)(implicit ctx: Context): Boolean = {
     def isOpsPackageObjectAppliedType: Boolean =
-      sym.owner == CompiletimeOpsPackageObject.moduleClass && compiletimePackageTypes.contains(sym.name)
+      sym.owner == CompiletimeOpsPackageObject.moduleClass && compiletimePackageTypes.contains(sym.name) ||
+      sym.owner == CompiletimeOpsPackageObjectInt.moduleClass && compiletimePackageIntTypes.contains(sym.name) ||
+      sym.owner == CompiletimeOpsPackageObjectString.moduleClass && compiletimePackageStringTypes.contains(sym.name)
 
     sym.isType && (isCompiletime_S(sym) || isOpsPackageObjectAppliedType)
   }

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

@@ -3619,6 +3619,11 @@ object Types {
           case _ => None
         }
 
+        def stringValue(tp: Type): Option[String] = tp match {
+          case ConstantType(Constant(n: String)) => Some(n)
+          case _ => None
+        }
+
         def natValue(tp: Type): Option[Int] = intValue(tp).filter(n => n >= 0 && n < Int.MaxValue)
 
         def constantFold1[T](extractor: Type => Option[T], op: T => Any): Option[Type] =
@@ -3641,7 +3646,10 @@ object Types {
           } else if (args.length == 2) tycon.symbol.name match {
             case tpnme.Equals => constantFold2(constValue, _ == _)
             case tpnme.NotEquals => constantFold2(constValue, _ != _)
-            case tpnme.Plus => constantFold2(intValue, _ + _)
+            case tpnme.Plus if tycon.symbol.owner == defn.CompiletimeOpsPackageObjectInt.moduleClass =>
+              constantFold2(intValue, _ + _)
+            case tpnme.Plus if tycon.symbol.owner == defn.CompiletimeOpsPackageObjectString.moduleClass =>
+              constantFold2(stringValue, _ + _)
             case tpnme.Minus => constantFold2(intValue, _ - _)
             case tpnme.Times => constantFold2(intValue, _ * _)
             case tpnme.Div => constantFold2(intValue, {

library/src/scala/compiletime/ops/package.scala

@@ -6,7 +6,13 @@ package object ops {
   @infix type ==[X <: AnyVal, Y <: AnyVal] <: Boolean
   @infix type !=[X <: AnyVal, Y <: AnyVal] <: Boolean
 
-  @infix type +[X <: Int, Y <: Int] <: Int
+  @infix type +[X <: Int | String, Y <: Int | String] = (X, Y) match {
+    case (Int, Int) => int.+[X, Y]
+    case (String, String) => string.+[X, Y]
+    case (String, Int) => string.+[X, ToString[Y]]
+    case (Int, String) => string.+[ToString[X], Y]
+  }
+
   @infix type -[X <: Int, Y <: Int] <: Int
   @infix type *[X <: Int, Y <: Int] <: Int
   @infix type /[X <: Int, Y <: Int] <: Int
@@ -27,4 +33,12 @@ package object ops {
   @infix type ^[X <: Boolean, Y <: Boolean] <: Boolean
   @infix type &&[X <: Boolean, Y <: Boolean] <: Boolean
   @infix type ||[X <: Boolean, Y <: Boolean] <: Boolean
+
+  private object string {
+    type +[X <: String, Y <: String] <: String
+  }
+
+  private object int {
+    type +[X <: Int, Y <: Int] <: Int
+  }
 }

tests/neg/singleton-ops.scala

@@ -97,4 +97,9 @@ object Test {
   val t69: ToString[-1] = "-1"
   val t70: ToString[0] = "-0" // error
   val t71: ToString[200] = "100" // error
+
+  val t72: "hello " + "world" = "hello world"
+  val t73: "hello " + 2 = "hello 2"
+  val t74: 2 + " hello" = "2 hello"
+  val t75: "hello" + "world" = "hi" // error
 }