Simplify TypeTag generation

Generate a type with embedded quotes instead of a tree.

Author: odersky

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

@@ -580,82 +580,23 @@ trait Implicits { self: Typer =>
     }
 
     def synthesizedTypeTag(formal: Type): Tree = formal.argInfos match {
-      case tpe :: Nil =>
-        var ok = true
-
-        def toParamSyms(tpe: LambdaType): List[Symbol { type ThisName = tpe.ThisName }] =
-          (tpe.paramNames, tpe.paramInfos).zipped.map((name, bounds) =>
-            ctx.newSymbol(ctx.owner, name, Param, bounds))
-
-        def toTreeAndDefs(tpe: Type): (List[TypeSymbol], List[List[TermSymbol]], Tree) = tpe match {
-          case tpe: TypeLambda =>
-            val tsyms = toParamSyms(tpe)
-            val (Nil, vsymss, result) = toTreeAndDefs(tpe.resultType.substParams(tpe, tsyms.map(_.typeRef)))
-            (tsyms, vsymss, result)
-          case tpe: TermLambda =>
-            val vsyms = toParamSyms(tpe)
-            val (Nil, vsymss, result) = toTreeAndDefs(tpe.resultType.substParams(tpe, vsyms.map(_.termRef)))
-            (Nil, vsyms :: vsymss, result)
-          case _ =>
-            (Nil, Nil, toTree(tpe))
-        }
-
-        def refinedToTree(tpe: Type, refinements: List[Tree], refineCls: ClassSymbol): Tree = tpe.stripTypeVar match {
-          case RefinedType(parent, rname, rinfo) =>
-            val isMethod = rinfo.isInstanceOf[MethodOrPoly]
-            val sym = ctx.newSymbol(refineCls, rname, if (isMethod) Method else EmptyFlags, rinfo)
-            val refinement = rname match {
-              case rname: TypeName =>
-                TypeDef(sym.asType)
-              case rname: TermName =>
-                if (isMethod) {
-                  val (tparams, vparamss, resTpt) = toTreeAndDefs(rinfo.asInstanceOf[MethodOrPoly])
-                  DefDef(sym.asTerm, tparams, vparamss, resTpt.tpe, EmptyTree)
-                }
-                else ValDef(sym.asTerm)
-            }
-            refinedToTree(parent, refinement :: refinements, refineCls)
-          case _ =>
-            RefinedTypeTree(toTree(tpe), refinements, refineCls)
-        }
-
-        def toTree(tpe: Type): Tree = tpe.stripTypeVar match {
-          case tpe @ TypeRef(NoPrefix, _) =>
-            inferImplicit(defn.QuotedTypeType.appliedTo(tpe), EmptyTree, pos) match {
-              case SearchSuccess(tag, _, _) =>
-                tag.select(defn.QuotedType_~)
-              case _ =>
-                ok = false
-                EmptyTree
-            }
-          case tpe: NamedType =>
-            ref(tpe)
-          case tpe: SingletonType =>
-            singleton(tpe)
-          case AppliedType(tycon, args) =>
-            AppliedTypeTree(toTree(tycon), args.map(toTree))
-          case AndType(l, r) =>
-            AndTypeTree(toTree(l), toTree(r))
-          case OrType(l, r) =>
-            OrTypeTree(toTree(l), toTree(r))
-          case tp: HKTypeLambda =>
-            val tsyms = toParamSyms(tp)
-            toTree(tp.resType.substParams(tp, tsyms.map(_.typeRef)))
-          case tpe: RecType =>
-            refinedToTree(tpe.parent, Nil, ctx.newRefinedClassSymbol())
-          case tpe: RefinedType =>
-            refinedToTree(tpe, Nil, ctx.newRefinedClassSymbol())
-          case TypeAlias(alias) =>
-            val aliasTree = toTree(alias)
-            TypeBoundsTree(aliasTree, aliasTree)
-          case TypeBounds(lo, hi) =>
-            TypeBoundsTree(toTree(lo), toTree(hi))
-          case _ =>
-            EmptyTree
+      case arg :: Nil =>
+        object bindFreeVars extends TypeMap {
+          var ok = true
+          def apply(t: Type) = t match {
+            case t @ TypeRef(NoPrefix, _) =>
+              inferImplicit(defn.QuotedTypeType.appliedTo(t), EmptyTree, pos) match {
+                case SearchSuccess(tag, _, _) if tag.tpe.isStable =>
+                  tag.tpe.select(defn.QuotedType_~)
+                case _ =>
+                  ok = false
+                  t
+              }
+            case _ => t
+          }
         }
-
-        val tag = toTree(tpe)
-        if (ok) ref(defn.typeQuoteMethod).appliedToTypeTrees(tag :: Nil)
+        val tag = bindFreeVars(arg)
+        if (bindFreeVars.ok) ref(defn.typeQuoteMethod).appliedToType(tag)
         else EmptyTree
       case _ =>
         EmptyTree