Merge pull request #1936 from retronym/ticket/6891

SI-6891 Fix value class + tailrec crasher.

6 files changed, 98 insertions, 3 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index 48a5a36b00..c5c3c560ea 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -117,7 +117,8 @@ abstract class TreeCheckers extends Analyzer {
     try p.source.path + ":" + p.line
     catch { case _: UnsupportedOperationException => p.toString }
 
-  def errorFn(msg: Any): Unit                = println("[check: %s] %s".format(phase.prev, msg))
+  private var hasError: Boolean = false
+  def errorFn(msg: Any): Unit                = {hasError = true; println("[check: %s] %s".format(phase.prev, msg))}
   def errorFn(pos: Position, msg: Any): Unit = errorFn(posstr(pos) + ": " + msg)
   def informFn(msg: Any) {
     if (settings.verbose.value || settings.debug.value)
@@ -151,6 +152,7 @@ abstract class TreeCheckers extends Analyzer {
     result
   }
   def runWithUnit[T](unit: CompilationUnit)(body: => Unit): Unit = {
+    hasError = false
     val unit0 = currentUnit
     currentRun.currentUnit = unit
     body
@@ -169,6 +171,7 @@ abstract class TreeCheckers extends Analyzer {
       checker.precheck.traverse(unit.body)
       checker.typed(unit.body)
       checker.postcheck.traverse(unit.body)
+      if (hasError) unit.warning(NoPosition, "TreeCheckers detected non-compliant trees in " + unit)
     }
   }
 
@@ -217,8 +220,11 @@ abstract class TreeCheckers extends Analyzer {
       case _ => ()
     }
 
-    object precheck extends Traverser {
+    object precheck extends TreeStackTraverser {
       override def traverse(tree: Tree) {
+        checkSymbolRefsRespectScope(tree)
+        checkReturnReferencesDirectlyEnclosingDef(tree)
+
         val sym = tree.symbol
         def accessed = sym.accessed
         def fail(msg: String) = errorFn(tree.pos, msg + classstr(tree) + " / " + tree)
@@ -289,6 +295,41 @@ abstract class TreeCheckers extends Analyzer {
         }
         super.traverse(tree)
       }
+
+      private def checkSymbolRefsRespectScope(tree: Tree) {
+        def symbolOf(t: Tree): Symbol = Option(tree.symbol).getOrElse(NoSymbol)
+        def definedSymbolOf(t: Tree): Symbol = if (t.isDef) symbolOf(t) else NoSymbol
+        val info = Option(symbolOf(tree).info).getOrElse(NoType)
+        val referencedSymbols: List[Symbol] = {
+          val directRef = tree match {
+            case _: RefTree => symbolOf(tree).toOption
+            case _          => None
+          }
+          def referencedSyms(tp: Type) = (tp collect {
+            case TypeRef(_, sym, _) => sym
+          }).toList
+          val indirectRefs = referencedSyms(info)
+          (indirectRefs ++ directRef).distinct
+        }
+        for {
+          sym <- referencedSymbols
+          if (sym.isTypeParameter || sym.isLocal) && !(tree.symbol hasTransOwner sym.owner)
+        } errorFn(s"The symbol, tpe or info of tree `(${tree}) : ${info}` refers to a out-of-scope symbol, ${sym.fullLocationString}. tree.symbol.ownerChain: ${tree.symbol.ownerChain.mkString(", ")}")
+      }
+
+      private def checkReturnReferencesDirectlyEnclosingDef(tree: Tree) {
+        tree match {
+          case _: Return =>
+            path.collectFirst {
+              case dd: DefDef => dd
+            } match {
+              case None => errorFn(s"Return node ($tree) must be enclosed in a DefDef")
+              case Some(dd) =>
+                if (tree.symbol != dd.symbol) errorFn(s"Return symbol (${tree.symbol}} does not reference directly enclosing DefDef (${dd.symbol})")
+            }
+          case _ =>
+        }
+      }
     }
 
     object postcheck extends Traverser {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 553583e6b7..fd134ac894 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1452,7 +1452,7 @@ trait Typers extends Modes with Adaptations with Tags {
           case DefDef(_, name, _, _, _, rhs) =>
             if (stat.symbol.isAuxiliaryConstructor)
               notAllowed("secondary constructor")
-            else if (isValueClass && (name == nme.equals_ || name == nme.hashCode_))
+            else if (isValueClass && (name == nme.equals_ || name == nme.hashCode_) && !stat.symbol.isSynthetic)
               notAllowed(s"redefinition of $name method. See SIP-15, criterion 4.")
             else if (stat.symbol != null && stat.symbol.isParamAccessor)
               notAllowed("additional parameter")
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index a4287fb181..c274a9e3af 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -1651,6 +1651,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 
     @inline final def map(f: Symbol => Symbol): Symbol = if (this eq NoSymbol) this else f(this)
 
+    final def toOption: Option[Symbol] = if (exists) Some(this) else None
+
 // ------ cloneing -------------------------------------------------------------------
 
     /** A clone of this symbol. */
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 431afd286d..a528a9ced8 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -1440,6 +1440,22 @@ trait Trees extends api.Trees { self: SymbolTable =>
       if (tree.hasSymbol) {
         subst(from, to)
         tree match {
+          case _: DefTree =>
+            val newInfo = symSubst(tree.symbol.info)
+            if (!(newInfo =:= tree.symbol.info)) {
+              debuglog(sm"""
+                |TreeSymSubstituter: updated info of symbol ${tree.symbol}
+                |  Old: ${showRaw(tree.symbol.info, printTypes = true, printIds = true)}
+                |  New: ${showRaw(newInfo, printTypes = true, printIds = true)}""")
+              tree.symbol updateInfo newInfo
+            }
+          case _          =>
+            // no special handling is required for Function or Import nodes here.
+            // as they don't have interesting infos attached to their symbols.
+            // Subsitution of the referenced symbol of Return nodes is handled
+            // in .ChangeOwnerTraverser
+        }
+        tree match {
           case Ident(name0) if tree.symbol != NoSymbol =>
             treeCopy.Ident(tree, tree.symbol.name)
           case Select(qual, name0) if tree.symbol != NoSymbol =>
@@ -1488,6 +1504,15 @@ trait Trees extends api.Trees { self: SymbolTable =>
     }
   }
 
+  trait TreeStackTraverser extends Traverser {
+    import collection.mutable
+    val path: mutable.Stack[Tree] = mutable.Stack()
+    abstract override def traverse(t: Tree) = {
+      path push t
+      try super.traverse(t) finally path.pop()
+    }
+  }
+
   private lazy val duplicator = new Transformer {
     override val treeCopy = newStrictTreeCopier
     override def transform(t: Tree) = {
diff --git a/test/files/pos/t6891.flags b/test/files/pos/t6891.flags
new file mode 100644
index 0000000000..fe048006aa
--- /dev/null
+++ b/test/files/pos/t6891.flags
@@ -0,0 +1 @@
+-Ycheck:extmethods -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t6891.scala b/test/files/pos/t6891.scala
new file mode 100644
index 0000000000..bed2d0d777
--- /dev/null
+++ b/test/files/pos/t6891.scala
@@ -0,0 +1,26 @@
+object O {
+  implicit class Foo[A](val value: String) extends AnyVal {
+    def bippy() = {
+      @annotation.tailrec def loop(x: A): Unit = loop(x)
+      ()
+    }
+
+    def boppy() = {
+      @annotation.tailrec def loop(x: value.type): Unit = loop(x)
+      ()
+    }
+
+    def beppy[C](c: => C) = {
+      () => c
+      @annotation.tailrec def loop(x: value.type): Unit = loop(x)
+        () => c
+      ()
+    }
+  }
+  // uncaught exception during compilation: Types$TypeError("type mismatch;
+  //  found   : A(in method bippy$extension)
+  //  required: A(in class Foo)") @ scala.tools.nsc.typechecker.Contexts$Context.issueCommon(Contexts.scala:396)
+  // error: scala.reflect.internal.Types$TypeError: type mismatch;
+  //  found   : A(in method bippy$extension)
+  //  required: A(in class Foo)
+}