[base-3] Rewrite quoted string and splice concatenation to be more amenable to -Xcheck-macros

Author: rayrobdod

Base/src/main/scala-3/typeclass/RepeatedImpl.scala

@@ -13,41 +13,23 @@ private[typeclass]
 object RepeatedImpl {
 	private[typeclass]
 	final class ConcatenateString(using Quotes) extends Repeated[Expr[String], Expr[String]] {
-		sealed trait Acc
-		object AccZero extends Acc
-		final class AccOne(val elem: Expr[String]) extends Acc
-		final class AccMany extends Acc {
-			val builder: Builder[Expr[String], Expr[String]] = List.newBuilder.mapResult(parts =>
-				'{
-					${
-						parts.foldLeft
-							('{new scala.collection.mutable.StringBuilder})
-							({(builder, part) => '{$builder.append($part)}})
-					}
-						.result
-				}
-			)
-		}
+		type Acc = List[Expr[String]]
 
-		def init():Acc = AccZero
-		def append(acc:Acc, elem:Expr[String]):Acc = acc match {
-			case AccZero => new AccOne(elem)
-			case accOne: AccOne => {
-				val retval = new AccMany()
-				retval.builder += accOne.elem
-				retval.builder += elem
-				retval
-			}
-			case accMany: AccMany => {
-				accMany.builder += elem
-				accMany
-			}
-		}
+		def init():Acc = Nil
+		def append(acc:Acc, elem:Expr[String]):Acc = elem :: acc
 		def result(acc:Acc):Expr[String] = {
 			acc match {
-				case AccZero => Expr[String]("")
-				case accOne: AccOne => accOne.elem
-				case accMany: AccMany => accMany.builder.result()
+				case List() => Expr[String]("")
+				case List(elem) => elem
+				case _ =>
+					'{
+						${
+							acc.foldRight
+								('{new scala.collection.mutable.StringBuilder})
+								({(part, builder) => '{$builder.append($part)}})
+						}
+							.result
+					}
 			}
 		}
 	}
@@ -60,79 +42,33 @@ object RepeatedImpl {
 			ifOneSplice: PartialFunction[Expr[Iterable[A]], Expr[Z]]
 			)(using Quotes, Type[A], Type[Z], Type[Builder[A, Z]],
 	) extends Repeated[SplicePiece[Expr, A], Expr[Z]] {
-		sealed trait Acc
-		object AccZero extends Acc
-		final class AccOneScalar(val elem: Expr[A]) extends Acc
-		final class AccOneSplice(val iter: Expr[Iterable[A]]) extends Acc
-		final class AccMany extends Acc {
-			val builder: Builder[Expr[Builder[A, Z]] => Expr[_], Expr[Z]] = List.newBuilder.mapResult(parts =>
-				'{
-					val accumulator: Builder[A, Z] = ${newAccumulator}
-					${Expr.block(
-						parts.map(part => part('accumulator)),
-						'{accumulator.result()}
-					)}
-				}
-			)
-		}
+		type Acc = List[SplicePiece[Expr, A]]
 
-		def init():Acc = AccZero
-		def append(acc:Acc, elem:SplicePiece[Expr, A]):Acc = acc match {
-			case AccZero =>
-				elem match {
-					case _: SplicePiece.Zero[Expr] => AccZero
-					case elemOne: SplicePiece.One[Expr, A] => new AccOneScalar(elemOne.elem)
-					case elemMany: SplicePiece.Many[Expr, A] => new AccOneSplice(elemMany.iter)
-				}
-			case accOne: AccOneScalar => {
-				elem match {
-					case _: SplicePiece.Zero[Expr] => accOne
-					case elemOne: SplicePiece.One[Expr, A] =>
-						val retval = new AccMany()
-						retval.builder += {(acc) => '{$acc.addOne(${accOne.elem})}}
-						retval.builder += {(acc) => '{$acc.addOne(${elemOne.elem})}}
-						retval
-					case elemMany: SplicePiece.Many[Expr, A] =>
-						val retval = new AccMany()
-						retval.builder += {(acc) => '{$acc.addOne(${accOne.elem})}}
-						retval.builder += {(acc) => '{$acc.addAll(${elemMany.iter})}}
-						retval
-				}
-			}
-			case accOne: AccOneSplice => {
-				elem match {
-					case _: SplicePiece.Zero[Expr] => accOne
-					case elemOne: SplicePiece.One[Expr, A] =>
-						val retval = new AccMany()
-						retval.builder += {(acc) => '{$acc.addAll(${accOne.iter})}}
-						retval.builder += {(acc) => '{$acc.addOne(${elemOne.elem})}}
-						retval
-					case elemMany: SplicePiece.Many[Expr, A] =>
-						val retval = new AccMany()
-						retval.builder += {(acc) => '{$acc.addAll(${accOne.iter})}}
-						retval.builder += {(acc) => '{$acc.addAll(${elemMany.iter})}}
-						retval
-				}
-			}
-			case accMany: AccMany => {
-				elem match {
-					case _: SplicePiece.Zero[Expr] =>
-						// do nothing
-					case elemOne: SplicePiece.One[Expr, A] =>
-						accMany.builder += {(acc) => '{$acc.addOne(${elemOne.elem})}}
-					case elemMany: SplicePiece.Many[Expr, A] =>
-						accMany.builder += {(acc) => '{$acc.addAll(${elemMany.iter})}}
-				}
-				accMany
+		def init():Acc = Nil
+		def append(acc:Acc, elem:SplicePiece[Expr, A]):Acc = {
+			elem match {
+				case _: SplicePiece.Zero[Expr] => acc
+				case other => other :: acc
 			}
 		}
 
 		def result(acc:Acc):Expr[Z] = {
 			acc match {
-				case AccZero => ifZero.map(_.apply()).getOrElse('{$newAccumulator.result()})
-				case accOne: AccOneScalar => ifOneScalar.applyOrElse(accOne.elem, e => '{$newAccumulator.addOne(${e}).result()})
-				case accOne: AccOneSplice => ifOneSplice.applyOrElse(accOne.iter, es => '{$newAccumulator.addAll(${es}).result()})
-				case accMany: AccMany => accMany.builder.result()
+				case Nil => ifZero.map(_.apply()).getOrElse('{$newAccumulator.result()})
+				case List(SplicePiece.One(elem)) => ifOneScalar.applyOrElse(elem, e => '{$newAccumulator.addOne(${e}).result()})
+				case List(SplicePiece.Many(iter)) => ifOneSplice.applyOrElse(iter, es => '{$newAccumulator.addAll(${es}).result()})
+				case _ =>
+					'{
+						val accumulator: Builder[A, Z] = ${newAccumulator}
+						${Expr.block(
+							acc.reverse.map({
+								case SplicePiece.Zero() => '{()}
+								case SplicePiece.One(elem) => '{accumulator.addOne($elem)}
+								case SplicePiece.Many(iter) => '{accumulator.addAll($iter)}
+							}),
+							'{accumulator.result()}
+						)}
+					}
 			}
 		}
 	}