Remove tpd.Splice.apply

Inline, remove dead code and simplify computations splice type

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1224,17 +1224,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** An extractor for typed splices */
-  object Splice {
-    def apply(tree: Tree)(implicit ctx: Context): Tree = {
-      val baseType = tree.tpe.baseType(defn.QuotedExprClass).orElse(tree.tpe.baseType(defn.QuotedTypeClass))
-      val argType =
-        if (baseType != NoType) baseType.argTypesHi.head
-        else defn.NothingType
-      ref(defn.InternalQuoted_exprSplice).appliedToTypes(List(argType, defn.QuoteContextClass.typeRef)).appliedTo(tree)
-    }
-  }
-
   /** A key to be used in a context property that tracks enclosing inlined calls */
   private val InlinedCalls = Property.Key[List[Tree]]()
 

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

@@ -74,7 +74,8 @@ trait QuotesAndSplices {
           if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
         val pat = typedPattern(tree.expr, defn.QuotedExprClass.typeRef.appliedTo(pt))(
           spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
-        Splice(pat)
+        val argType = pat.tpe.baseType(defn.QuotedExprClass).argTypesHi.head
+        ref(defn.InternalQuoted_exprSplice).appliedToTypes(List(argType, defn.QuoteContextClass.typeRef)).appliedTo(pat)
       }
       else {
         ctx.error(i"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.sourcePos)
@@ -204,7 +205,11 @@ trait QuotesAndSplices {
         case Typed(Apply(fn, pat :: Nil), tpt) if fn.symbol == defn.InternalQuoted_exprSplice && !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
           val tpt1 = transform(tpt) // Transform type bindings
           val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
-          transform(Splice(Typed(pat, exprTpt)))
+          val newSplice =
+            ref(defn.InternalQuoted_exprSplice)
+              .appliedToTypes(List(tpt1.tpe, defn.QuoteContextClass.typeRef))
+              .appliedTo(Typed(pat, exprTpt))
+          transform(newSplice)
         case Apply(fn, pat :: Nil) if fn.symbol == defn.InternalQuoted_exprSplice =>
           try ref(defn.InternalQuoted_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {