Move compiletime ops into subpackages

As discussed IRL with @OlivierBlanvillain, the previous approach with a
match type dispatching to the correct overloaded op is not ideal, since
adding more ops will mean modifying previous ops. For now, we therefore
focus on having a good internal implementation of the ops.

In some cases, the syntax is not ideal. For instance:

    import scala.compiletime.ops.int._
    import scala.compiletime.ops.string._

    summon[1 + 2]
    //       ^ Reference to + is ambiguous
    //         it is both imported by import scala.compiletime.ops.int._
    //         and imported subsequently by import scala.compiletime.ops.string._

Or:

    import scala.compiletime.ops._
    summon[1 int.+ 2]
    //          ^ an identifier expected, but '.' found

These cases can be improved by allowing infix qualified types, or 
implementing resolution of member types (i.e. `A + B` as `A#+[B]`
instead of `+[A, B]`).

Author: MaximeKjaer

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

@@ -236,6 +236,7 @@ class Definitions {
   @tu lazy val CompiletimeOpsPackageObject: Symbol = ctx.requiredModule("scala.compiletime.ops.package")
     @tu lazy val CompiletimeOpsPackageObjectInt: Symbol = ctx.requiredModule("scala.compiletime.ops.package.int")
     @tu lazy val CompiletimeOpsPackageObjectString: Symbol = ctx.requiredModule("scala.compiletime.ops.package.string")
+    @tu lazy val CompiletimeOpsPackageObjectBoolean: Symbol = ctx.requiredModule("scala.compiletime.ops.package.boolean")
 
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will
@@ -901,20 +902,20 @@ class Definitions {
   final def isCompiletime_S(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.name == tpnme.S && sym.owner == CompiletimePackageObject.moduleClass
 
-  private val compiletimePackageTypes: Set[Name] = Set(
-    tpnme.Equals, tpnme.NotEquals,
-    tpnme.Minus, tpnme.Times, tpnme.Div, tpnme.Mod,
+  private val compiletimePackageTypes: Set[Name] = Set(tpnme.Equals, tpnme.NotEquals)
+  private val compiletimePackageIntTypes: Set[Name] = Set(
+    tpnme.Plus, 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 compiletimePackageBooleanTypes: Set[Name] = Set(tpnme.Not, tpnme.Xor, tpnme.And, tpnme.Or)
   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 == CompiletimeOpsPackageObjectInt.moduleClass && compiletimePackageIntTypes.contains(sym.name) ||
+      sym.owner == CompiletimeOpsPackageObjectBoolean.moduleClass && compiletimePackageBooleanTypes.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

@@ -3636,41 +3636,49 @@ object Types {
           } yield ConstantType(Constant(op(a, b)))
 
         trace(i"compiletime constant fold $this", typr, show = true) {
-          val constantType = if (args.length == 1) tycon.symbol.name match {
-            case tpnme.S => constantFold1(natValue, _ + 1)
-            case tpnme.Abs => constantFold1(intValue, _.abs)
-            case tpnme.Negate => constantFold1(intValue, x => -x)
-            case tpnme.Not => constantFold1(boolValue, x => !x)
-            case tpnme.ToString => constantFold1(intValue, _.toString)
-            case _ => None
-          } else if (args.length == 2) tycon.symbol.name match {
-            case tpnme.Equals => constantFold2(constValue, _ == _)
-            case tpnme.NotEquals => constantFold2(constValue, _ != _)
-            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, {
-              case (_, 0) => throw new TypeError("Division by 0")
-              case (a, b) => a / b
-            })
-            case tpnme.Mod => constantFold2(intValue, {
-              case (_, 0) => throw new TypeError("Modulo by 0")
-              case (a, b) => a % b
-            })
-            case tpnme.Lt => constantFold2(intValue, _ < _)
-            case tpnme.Gt => constantFold2(intValue, _ > _)
-            case tpnme.Ge => constantFold2(intValue, _ >= _)
-            case tpnme.Le => constantFold2(intValue, _ <= _)
-            case tpnme.Min => constantFold2(intValue, _ min _)
-            case tpnme.Max => constantFold2(intValue, _ max _)
-            case tpnme.And => constantFold2(boolValue, _ && _)
-            case tpnme.Or => constantFold2(boolValue, _ || _)
-            case tpnme.Xor => constantFold2(boolValue, _ ^ _)
-            case _ => None
-          } else None
+          val name = tycon.symbol.name
+          val owner = tycon.symbol.owner
+          val nArgs = args.length
+          val constantType =
+            if (owner == defn.CompiletimePackageObject.moduleClass) name match {
+              case tpnme.S if nArgs == 1 => constantFold1(natValue, _ + 1)
+              case _ => None
+            } else if (owner == defn.CompiletimeOpsPackageObject.moduleClass) name match {
+              case tpnme.Equals    if nArgs == 2 => constantFold2(constValue, _ == _)
+              case tpnme.NotEquals if nArgs == 2 => constantFold2(constValue, _ != _)
+              case _ => None
+            } else if (owner == defn.CompiletimeOpsPackageObjectInt.moduleClass) name match {
+              case tpnme.Abs      if nArgs == 1 => constantFold1(intValue, _.abs)
+              case tpnme.Negate   if nArgs == 1 => constantFold1(intValue, x => -x)
+              case tpnme.ToString if nArgs == 1 => constantFold1(intValue, _.toString)
+              case tpnme.Plus     if nArgs == 2 => constantFold2(intValue, _ + _)
+              case tpnme.Minus    if nArgs == 2 => constantFold2(intValue, _ - _)
+              case tpnme.Times    if nArgs == 2 => constantFold2(intValue, _ * _)
+              case tpnme.Div if nArgs == 2 => constantFold2(intValue, {
+                case (_, 0) => throw new TypeError("Division by 0")
+                case (a, b) => a / b
+              })
+              case tpnme.Mod if nArgs == 2 => constantFold2(intValue, {
+                case (_, 0) => throw new TypeError("Modulo by 0")
+                case (a, b) => a % b
+              })
+              case tpnme.Lt  if nArgs == 2 => constantFold2(intValue, _ < _)
+              case tpnme.Gt  if nArgs == 2 => constantFold2(intValue, _ > _)
+              case tpnme.Ge  if nArgs == 2 => constantFold2(intValue, _ >= _)
+              case tpnme.Le  if nArgs == 2 => constantFold2(intValue, _ <= _)
+              case tpnme.Min if nArgs == 2 => constantFold2(intValue, _ min _)
+              case tpnme.Max if nArgs == 2 => constantFold2(intValue, _ max _)
+              case _ => None
+            } else if (owner == defn.CompiletimeOpsPackageObjectString.moduleClass) name match {
+              case tpnme.Plus if nArgs == 2 => constantFold2(stringValue, _ + _)
+              case _ => None
+            } else if (owner == defn.CompiletimeOpsPackageObjectBoolean.moduleClass) name match {
+              case tpnme.Not if nArgs == 1 => constantFold1(boolValue, x => !x)
+              case tpnme.And if nArgs == 2 => constantFold2(boolValue, _ && _)
+              case tpnme.Or  if nArgs == 2 => constantFold2(boolValue, _ || _)
+              case tpnme.Xor if nArgs == 2 => constantFold2(boolValue, _ ^ _)
+              case _ => None
+            } else None
 
           constantType.getOrElse(NoType)
         }

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

@@ -6,39 +6,33 @@ package object ops {
   @infix type ==[X <: AnyVal, Y <: AnyVal] <: Boolean
   @infix type !=[X <: AnyVal, Y <: AnyVal] <: Boolean
 
-  @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]
+  object string {
+    @infix type +[X <: String, Y <: String] <: String
   }
 
-  @infix type -[X <: Int, Y <: Int] <: Int
-  @infix type *[X <: Int, Y <: Int] <: Int
-  @infix type /[X <: Int, Y <: Int] <: Int
-  @infix type %[X <: Int, Y <: Int] <: Int
-
-  @infix type <[X <: Int, Y <: Int] <: Boolean
-  @infix type >[X <: Int, Y <: Int] <: Boolean
-  @infix type >=[X <: Int, Y <: Int] <: Boolean
-  @infix type <=[X <: Int, Y <: Int] <: Boolean
-
-  type Abs[X <: Int] <: Int
-  type Negate[X <: Int] <: Int
-  type Min[X <: Int, Y <: Int] <: Int
-  type Max[X <: Int, Y <: Int] <: Int
-  type ToString[X <: Int] <: String
-
-  type ![X <: Boolean] <: Boolean
-  @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
+  object int {
+    @infix type +[X <: Int, Y <: Int] <: Int
+    @infix type -[X <: Int, Y <: Int] <: Int
+    @infix type *[X <: Int, Y <: Int] <: Int
+    @infix type /[X <: Int, Y <: Int] <: Int
+    @infix type %[X <: Int, Y <: Int] <: Int
+
+    @infix type <[X <: Int, Y <: Int] <: Boolean
+    @infix type >[X <: Int, Y <: Int] <: Boolean
+    @infix type >=[X <: Int, Y <: Int] <: Boolean
+    @infix type <=[X <: Int, Y <: Int] <: Boolean
+
+    type Abs[X <: Int] <: Int
+    type Negate[X <: Int] <: Int
+    type Min[X <: Int, Y <: Int] <: Int
+    type Max[X <: Int, Y <: Int] <: Int
+    type ToString[X <: Int] <: String
   }
 
-  private object int {
-    type +[X <: Int, Y <: Int] <: Int
+  object boolean {
+    type ![X <: Boolean] <: Boolean
+    @infix type ^[X <: Boolean, Y <: Boolean] <: Boolean
+    @infix type &&[X <: Boolean, Y <: Boolean] <: Boolean
+    @infix type ||[X <: Boolean, Y <: Boolean] <: Boolean
   }
 }

tests/neg/singleton-ops-boolean.scala

@@ -0,0 +1,23 @@
+import scala.compiletime.ops.boolean._
+
+object Test {
+  val t0: ![true] = false
+  val t1: ![false] = true
+  val t2: ![true] = true // error
+  val t3: ![false] = false // error
+
+  val t4: true && true = true
+  val t5: true && false = false
+  val t6: false && true = true // error
+  val t7: false && false = true // error
+
+  val t8: true ^ true = false
+  val t9: false ^ true = true
+  val t10: false ^ false = true // error
+  val t11: true ^ false = false // error
+
+  val t12: true || true = true
+  val t13: true || false = true
+  val t14 false || true = false // error
+  val t15: false || false = true // error
+}

tests/neg/singleton-ops-int.scala

@@ -0,0 +1,75 @@
+import scala.compiletime.ops.int._
+
+object Test {
+  summon[2 + 3 =:= 6 - 1]
+  summon[1763 =:= 41 * 43]
+  summon[2 + 2 =:= 3] // error
+  summon[29 * 31 =:= 900] // error
+  summon[Int <:< Int + 1] // error
+  summon[1 + Int <:< Int]
+
+  val t0: 2 + 3 = 5
+  val t1: 2 + 2 = 5 // error
+  val t2: -1 + 1 = 0
+  val t3: -5 + -5 = -11 // error
+
+  val t4: 10 * 20 = 200
+  val t5: 30 * 10 = 400 // error
+  val t6: -10 * 2  = -20
+  val t7: -2 * -2 = 4
+
+  val t8: 10 / 2 = 5
+  val t9: 11 / -2 = -5 // Integer division
+  val t10: 2 / 4 = 2 // error
+  val t11: -1 / 0 = 1 // error
+
+  val t12: 10 % 3 = 1
+  val t13: 12 % 2 = 1 // error
+  val t14: 1 % -3 = 1
+  val t15: -3 % 0 = 0 // error
+
+  val t16: 1 < 0 = false
+  val t17: 0 < 1 = true
+  val t18: 10 < 5 = true // error
+  val t19: 5 < 10 = false // error
+
+  val t20: 1 <= 0 = false
+  val t21: 1 <= 1 = true
+  val t22: 10 <= 5 = true // error
+  val t23: 5 <= 10 = false // error
+
+  val t24: 1 > 0 = true
+  val t25: 0 > 1 = false
+  val t26: 10 > 5 = false // error
+  val t27: 5 > 10 = true // error
+
+  val t28: 1 >= 1 = true
+  val t29: 0 >= 1 = false
+  val t30: 10 >= 5 = false // error
+  val t31: 5 >= 10 = true // error
+
+  val t32: Abs[0] = 0
+  val t33: Abs[-1] = 1
+  val t34: Abs[-1] = -1 // error
+  val t35: Abs[1] = -1 // error
+
+  val t36: Negate[-10] = 10
+  val t37: Negate[10] = -10
+  val t38: Negate[1] = 1 // error
+  val t39: Negate[-1] = -1 // error
+
+  val t40: Max[-1, 10] = 10
+  val t41: Max[4, 2] = 4
+  val t42: Max[2, 2] = 1 // error
+  val t43: Max[-1, -1] = 0 // error
+
+  val t44: Min[-1, 10] = -1
+  val t45: Min[4, 2] = 2
+  val t46: Min[2, 2] = 1 // error
+  val t47: Min[-1, -1] = 0 // error
+
+  val t48: ToString[213] = "213"
+  val t49: ToString[-1] = "-1"
+  val t50: ToString[0] = "-0" // error
+  val t51: ToString[200] = "100" // error
+}

tests/neg/singleton-ops-match-type-scrutinee.scala

@@ -1,4 +1,4 @@
-import scala.compiletime.ops._
+import scala.compiletime.ops.int._
 
 object Test {
   type Max2[A <: Int, B <: Int] <: Int = (A < B) match {

tests/neg/singleton-ops-recursive-match-type.scala

@@ -1,4 +1,4 @@
-import scala.compiletime.ops._
+import scala.compiletime.ops.int._
 
 object Test {
   type GCD[A <: Int, B <: Int] <: Int = B match {

tests/neg/singleton-ops-string.scala

@@ -0,0 +1,8 @@
+import scala.compiletime.ops.string._
+
+object Test {
+  val t0: "Hello " + "world" = "Hello world"
+  val t1: "" + "" = ""
+  val t2: "3" + "" = "33" // error
+  val t3: "Hello " + "world" = "error" // error
+}

tests/neg/singleton-ops-type-alias.scala

@@ -1,4 +1,4 @@
-import scala.compiletime.ops._
+import scala.compiletime.ops.boolean._
 
 object Test {
   type Xor[A <: Boolean, B <: Boolean] = (A && ![B]) || (![A] && B)