Merge pull request #5138 from dotty-staging/revert-inliner

Revert inliner to work on typed trees

Author: odersky

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

@@ -497,10 +497,6 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = If[T]
   }
-  class InlineIf[T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])
-    extends If(cond, thenp, elsep) {
-    override def toString = s"InlineIf($cond, $thenp, $elsep)"
-  }
 
   /** A closure with an environment and a reference to a method.
    *  @param env    The captured parameters of the closure
@@ -521,10 +517,6 @@ object Trees {
     extends TermTree[T] {
     type ThisTree[-T >: Untyped] = Match[T]
   }
-  class InlineMatch[T >: Untyped] private[ast] (selector: Tree[T], cases: List[CaseDef[T]])
-    extends Match(selector, cases) {
-    override def toString = s"InlineMatch($selector, $cases)"
-  }
 
   /** case pat if guard => body; only appears as child of a Match */
   case class CaseDef[-T >: Untyped] private[ast] (pat: Tree[T], guard: Tree[T], body: Tree[T])
@@ -910,10 +902,8 @@ object Trees {
     type Assign = Trees.Assign[T]
     type Block = Trees.Block[T]
     type If = Trees.If[T]
-    type InlineIf = Trees.InlineIf[T]
     type Closure = Trees.Closure[T]
     type Match = Trees.Match[T]
-    type InlineMatch = Trees.InlineMatch[T]
     type CaseDef = Trees.CaseDef[T]
     type Labeled = Trees.Labeled[T]
     type Return = Trees.Return[T]
@@ -959,11 +949,6 @@ object Trees {
       case ys => Thicket(ys)
     }
 
-    /** Extractor for the synthetic scrutinee tree of an implicit match */
-    object ImplicitScrutinee {
-      def apply() = Ident(nme.IMPLICITkw)
-      def unapply(id: Ident): Boolean = id.name == nme.IMPLICITkw && !id.isInstanceOf[BackquotedIdent]
-    }
     // ----- Helper classes for copying, transforming, accumulating -----------------
 
     val cpy: TreeCopier
@@ -1045,9 +1030,6 @@ object Trees {
         case _ => finalize(tree, untpd.Block(stats, expr))
       }
       def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If = tree match {
-        case tree: InlineIf =>
-          if ((cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep)) tree
-          else finalize(tree, untpd.InlineIf(cond, thenp, elsep))
         case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
         case _ => finalize(tree, untpd.If(cond, thenp, elsep))
       }
@@ -1056,9 +1038,6 @@ object Trees {
         case _ => finalize(tree, untpd.Closure(env, meth, tpt))
       }
       def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = tree match {
-        case tree: InlineMatch =>
-          if ((selector eq tree.selector) && (cases eq tree.cases)) tree
-          else finalize(tree, untpd.InlineMatch(selector, cases))
         case tree: Match if (selector eq tree.selector) && (cases eq tree.cases) => tree
         case _ => finalize(tree, untpd.Match(selector, cases))
       }
@@ -1169,10 +1148,6 @@ object Trees {
         case tree: Annotated if (arg eq tree.arg) && (annot eq tree.annot) => tree
         case _ => finalize(tree, untpd.Annotated(arg, annot))
       }
-      def UntypedSplice(tree: Tree)(splice: untpd.Tree) = tree match {
-        case tree: tpd.UntypedSplice if tree.splice `eq` splice => tree
-        case _ => finalize(tree, tpd.UntypedSplice(splice))
-      }
       def Thicket(tree: Tree)(trees: List[Tree]): Thicket = tree match {
         case tree: Thicket if trees eq tree.trees => tree
         case _ => finalize(tree, untpd.Thicket(trees))
@@ -1329,21 +1304,9 @@ object Trees {
       def transformSub[Tr <: Tree](trees: List[Tr])(implicit ctx: Context): List[Tr] =
         transform(trees).asInstanceOf[List[Tr]]
 
-      protected def transformMoreCases(tree: Tree)(implicit ctx: Context): Tree = tree match {
-        case tpd.UntypedSplice(usplice) =>
-          // For a typed tree map: homomorphism on the untyped part with
-          // recursive mapping of typed splices.
-          // The case is overridden in UntypedTreeMap.##
-          val untpdMap = new untpd.UntypedTreeMap {
-            override def transform(tree: untpd.Tree)(implicit ctx: Context): untpd.Tree = tree match {
-              case untpd.TypedSplice(tsplice) =>
-                untpd.cpy.TypedSplice(tree)(self.transform(tsplice).asInstanceOf[tpd.Tree])
-                  // the cast is safe, since the UntypedSplice case is overridden in UntypedTreeMap.
-              case _ => super.transform(tree)
-            }
-          }
-          cpy.UntypedSplice(tree)(untpdMap.transform(usplice))
-        case _ if ctx.reporter.errorsReported => tree
+      protected def transformMoreCases(tree: Tree)(implicit ctx: Context): Tree = {
+        assert(ctx.reporter.errorsReported)
+        tree
       }
     }
 
@@ -1453,23 +1416,13 @@ object Trees {
         }
       }
 
-      def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = tree match {
-        case tpd.UntypedSplice(usplice) =>
-          // For a typed tree accumulator: skip the untyped part and fold all typed splices.
-          // The case is overridden in UntypedTreeAccumulator.
-          val untpdAcc = new untpd.UntypedTreeAccumulator[X] {
-            override def apply(x: X, tree: untpd.Tree)(implicit ctx: Context): X = tree match {
-              case untpd.TypedSplice(tsplice) => self(x, tsplice)
-              case _ => foldOver(x, tree)
-            }
-          }
-          untpdAcc(x, usplice)
-        case _ if ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive) =>
+      def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = {
+        assert(ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive))
           // In interactive mode, errors might come from previous runs.
           // In case of errors it may be that typed trees point to untyped ones.
           // The IDE can still traverse inside such trees, either in the run where errors
           // are reported, or in subsequent ones.
-          x
+        x
       }
     }
 

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

@@ -21,8 +21,6 @@ import scala.io.Codec
 /** Some creators for typed trees */
 object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
-  case class UntypedSplice(splice: untpd.Tree) extends Tree
-
   private def ta(implicit ctx: Context) = ctx.typeAssigner
 
   def Ident(tp: NamedType)(implicit ctx: Context): Ident =
@@ -722,7 +720,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           new TreeTypeMap(oldOwners = from :: froms, newOwners = tos).apply(tree)
         }
       }
-      loop(from, Nil, to :: Nil)
+      if (from == to) tree else loop(from, Nil, to :: Nil)
     }
 
     /** After phase `trans`, set the owner of every definition in this tree that was formerly
@@ -916,6 +914,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def outerSelect(levels: Int, tp: Type)(implicit ctx: Context): Tree =
       untpd.Select(tree, OuterSelectName(EmptyTermName, levels)).withType(SkolemType(tp))
 
+    def underlyingArgument(implicit ctx: Context): Tree = mapToUnderlying.transform(tree)
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */
@@ -942,26 +942,38 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
+  /** Map Inlined nodes and InlineProxy references to underlying arguments */
+  object mapToUnderlying extends TreeMap {
+    override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
+      case tree: Ident if tree.symbol.is(InlineProxy) =>
+        tree.symbol.defTree.asInstanceOf[ValOrDefDef].rhs.underlyingArgument
+      case Inlined(_, _, arg) =>
+        arg.underlyingArgument
+      case tree =>
+        super.transform(tree)
+    }
+  }
+
   implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {
     def tpes: List[Type] = xs map (_.tpe)
   }
 
   /** A trait for loaders that compute trees. Currently implemented just by DottyUnpickler. */
   trait TreeProvider {
-    protected def computeTrees(implicit ctx: Context): List[Tree]
+    protected def computeRootTrees(implicit ctx: Context): List[Tree]
 
     private[this] var myTrees: List[Tree] = null
 
     /** Get trees defined by this provider. Cache them if -Yretain-trees is set. */
-    def trees(implicit ctx: Context): List[Tree] =
+    def rootTrees(implicit ctx: Context): List[Tree] =
       if (ctx.settings.YretainTrees.value) {
-        if (myTrees == null) myTrees = computeTrees
+        if (myTrees == null) myTrees = computeRootTrees
         myTrees
-      } else computeTrees
+      } else computeRootTrees
 
     /** Get first tree defined by this provider, or EmptyTree if none exists */
     def tree(implicit ctx: Context): Tree =
-      trees.headOption.getOrElse(EmptyTree)
+      rootTrees.headOption.getOrElse(EmptyTree)
 
     /** Is it possible that the tree to load contains a definition of or reference to `id`? */
     def mightContain(id: String)(implicit ctx: Context) = true

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

@@ -272,10 +272,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Assign(lhs: Tree, rhs: Tree): Assign = new Assign(lhs, rhs)
   def Block(stats: List[Tree], expr: Tree): Block = new Block(stats, expr)
   def If(cond: Tree, thenp: Tree, elsep: Tree): If = new If(cond, thenp, elsep)
-  def InlineIf(cond: Tree, thenp: Tree, elsep: Tree): If = new InlineIf(cond, thenp, elsep)
   def Closure(env: List[Tree], meth: Tree, tpt: Tree): Closure = new Closure(env, meth, tpt)
   def Match(selector: Tree, cases: List[CaseDef]): Match = new Match(selector, cases)
-  def InlineMatch(selector: Tree, cases: List[CaseDef]): Match = new InlineMatch(selector, cases)
   def CaseDef(pat: Tree, guard: Tree, body: Tree): CaseDef = new CaseDef(pat, guard, body)
   def Labeled(bind: Bind, expr: Tree): Labeled = new Labeled(bind, expr)
   def Return(expr: Tree, from: Tree): Return = new Return(expr, from)
@@ -544,8 +542,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.ContextBounds(tree)(transformSub(bounds), transform(cxBounds))
       case PatDef(mods, pats, tpt, rhs) =>
         cpy.PatDef(tree)(mods, transform(pats), transform(tpt), transform(rhs))
-      case tpd.UntypedSplice(splice) =>
-        cpy.UntypedSplice(tree)(transform(splice))
       case TypedSplice(_) =>
         tree
       case _ =>
@@ -595,8 +591,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(this(this(x, pats), tpt), rhs)
       case TypedSplice(splice) =>
         this(x, splice)
-      case tpd.UntypedSplice(splice) =>
-        this(x, splice)
       case _ =>
         super.foldMoreCases(x, tree)
     }

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

@@ -363,6 +363,13 @@ trait ConstraintHandling {
   final def canConstrain(param: TypeParamRef): Boolean =
     (!frozenConstraint || (caseLambda `eq` param.binder)) && constraint.contains(param)
 
+  /** Is `param` assumed to be a sub- and super-type of any other type?
+   *  This holds if `TypeVarsMissContext` is set unless `param` is a part
+   *  of a MatchType that is currently normalized.
+   */
+  final def assumedTrue(param: TypeParamRef): Boolean =
+    ctx.mode.is(Mode.TypevarsMissContext) && (caseLambda `ne` param.binder)
+
   /** Add constraint `param <: bound` if `fromBelow` is false, `param >: bound` otherwise.
    *  `bound` is assumed to be in normalized form, as specified in `firstTry` and
    *  `secondTry` of `TypeComparer`. In particular, it should not be an alias type,

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

@@ -342,10 +342,6 @@ class Definitions {
   def NullType = NullClass.typeRef
   lazy val RuntimeNullModuleRef = ctx.requiredModuleRef("scala.runtime.Null")
 
-  lazy val ImplicitScrutineeTypeSym =
-    newSymbol(ScalaPackageClass, tpnme.IMPLICITkw, EmptyFlags, TypeBounds.empty).entered
-  def ImplicitScrutineeTypeRef: TypeRef = ImplicitScrutineeTypeSym.typeRef
-
   lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context) = ScalaPredefModuleRef.symbol
 
@@ -939,7 +935,8 @@ class Definitions {
   def scalaClassName(ref: Type)(implicit ctx: Context): TypeName = scalaClassName(ref.classSymbol)
 
   private def isVarArityClass(cls: Symbol, prefix: String) =
-    scalaClassName(cls).testSimple(name =>
+    cls.isClass && cls.owner.eq(ScalaPackageClass) &&
+    cls.name.testSimple(name =>
       name.startsWith(prefix) &&
       name.length > prefix.length &&
       name.drop(prefix.length).forall(_.isDigit))
@@ -1159,6 +1156,14 @@ class Definitions {
   def isAssuredNoInits(sym: Symbol) =
     (sym `eq` SomeClass) || isTupleClass(sym)
 
+  /** If `cls` is Tuple1..Tuple22, add the corresponding *: type as last parent to `parents` */
+  def adjustForTuple(cls: ClassSymbol, tparams: List[TypeSymbol], parents: List[Type]): List[Type] = {
+    def syntheticParent(tparams: List[TypeSymbol]): Type =
+      if (tparams.isEmpty) TupleTypeRef
+      else (tparams :\ (UnitType: Type)) ((tparam, tail) => PairType.appliedTo(tparam.typeRef, tail))
+    if (isTupleClass(cls) || cls == UnitClass) parents :+ syntheticParent(tparams) else parents
+  }
+
   // ----- primitive value class machinery ------------------------------------------
 
   /** This class would also be obviated by the implicit function type design */
@@ -1254,33 +1259,12 @@ class Definitions {
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticCoreMethods =
-    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod, ImplicitScrutineeTypeSym)
+    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 
   private[this] var isInitialized = false
 
-  /** Add a `Tuple` as a parent to `Unit`.
-   *  Add the right `*:` instance as a parent to Tuple1..Tuple22
-   */
-  def fixTupleCompleter(cls: ClassSymbol): Unit = cls.infoOrCompleter match {
-    case completer: LazyType =>
-      cls.info = new LazyType {
-        def syntheticParent(tparams: List[TypeSymbol]): Type =
-          if (tparams.isEmpty) TupleTypeRef
-          else (tparams :\ (UnitType: Type)) ((tparam, tail) => PairType.appliedTo(tparam.typeRef, tail))
-        override def complete(denot: SymDenotation)(implicit ctx: Context) = {
-          completer.complete(denot)
-          denot.info match {
-            case info: ClassInfo =>
-              denot.info = info.derivedClassInfo(
-                classParents = info.classParents :+ syntheticParent(cls.typeParams))
-          }
-        }
-      }
-    case _ =>
-  }
-
   def init()(implicit ctx: Context) = {
     this.ctx = ctx
     if (!isInitialized) {
@@ -1298,10 +1282,6 @@ class Definitions {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
       val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
 
-      fixTupleCompleter(UnitClass)
-      for (i <- 1 to MaxTupleArity)
-        fixTupleCompleter(TupleType(i).symbol.asClass)
-
       isInitialized = true
     }
   }

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

@@ -351,6 +351,9 @@ object Flags {
   /** A bridge method. Set by Erasure */
   final val Bridge = termFlag(34, "<bridge>")
 
+  /** A proxy for an argument to an inline method */
+  final val InlineProxy = termFlag(35, "<inline proxy>")
+
   /** Symbol is a method which should be marked ACC_SYNCHRONIZED */
   final val Synchronized = termFlag(36, "<synchronized>")
 
@@ -545,6 +548,9 @@ object Flags {
   /** Either method or lazy or deferred */
   final val MethodOrLazyOrDeferred = Method | Lazy | Deferred
 
+  /** An inline method or inline argument proxy */
+  final val InlineOrProxy = Inline | InlineProxy
+
   /** Assumed to be pure */
   final val StableOrErased = Stable | Erased