Merge branch 'master' into topic/i6014

Author: abgruszecki

community-build/community-projects/minitest

@@ -2076,15 +2076,14 @@ object TypeComparer {
   /** Show trace of comparison operations when performing `op` as result string */
   def explaining[T](say: String => Unit)(op: Context => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
-    val res = op(nestedCtx)
-    say(nestedCtx.typeComparer.lastTrace())
+    val res = try { op(nestedCtx) } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 
   /** Like [[explaining]], but returns the trace instead */
   def explained[T](op: Context => T)(implicit ctx: Context): String = {
     var trace: String = null
-    explaining(trace = _)(op)
+    try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace
   }
 }

community-build/community-projects/sourcecode

@@ -3,13 +3,16 @@ package tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import dotty.tools.dotc.ast.tpd.TreeOps
+import dotty.tools.dotc.typer.Typer
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.tastyreflect.FromSymbol.{definitionFromSym, packageDefFromSym}
+import dotty.tools.dotc.parsing.Parsers.Parser
+import dotty.tools.dotc.util.SourceFile
 
 import scala.tasty.reflect.Kernel
 
@@ -36,9 +39,15 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def error(msg: => String, pos: Position)(implicit ctx: Context): Unit =
     ctx.error(msg, pos)
 
+  def error(msg: => String, sourceFile: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit =
+    ctx.error(msg, util.SourcePosition(sourceFile, util.Spans.Span(start, end)))
+
   def warning(msg: => String, pos: Position)(implicit ctx: Context): Unit =
     ctx.warning(msg, pos)
 
+  def warning(msg: => String, sourceFile: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit =
+    ctx.error(msg, util.SourcePosition(sourceFile, util.Spans.Span(start, end)))
+
   //
   // Settings
   //
@@ -47,6 +56,26 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Settings_color(self: Settings): Boolean = self.color.value(rootContext) == "always"
 
+  //
+  // MISC
+  //
+  /** Whether the code type checks in the given context?
+   *
+   *  @param code The code to be type checked
+   *
+   *  The code should be a sequence of expressions or statements that may appear in a block.
+   */
+  def typeChecks(code: String)(implicit ctx: Context): Boolean = {
+    val ctx2 = ctx.fresh.setNewTyperState().setTyper(new Typer)
+    val tree = new Parser(SourceFile.virtual("tasty-reflect", code))(ctx2).block()
+
+    if (ctx2.reporter.hasErrors) false
+    else {
+      ctx2.typer.typed(tree)(ctx2)
+      !ctx2.reporter.hasErrors
+    }
+  }
+
   //
   // TREES
   //
@@ -493,7 +522,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   type Match = tpd.Match
 
   def matchMatch(x: Term)(implicit ctx: Context): Option[Match] = x match {
-    case x: tpd.Match => Some(x)
+    case x: tpd.Match if !x.selector.isEmpty => Some(x)
     case _ => None
   }
 
@@ -506,6 +535,21 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Match_copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match =
     tpd.cpy.Match(original)(selector, cases)
 
+  type ImplicitMatch = tpd.Match
+
+  def matchImplicitMatch(x: Term)(implicit ctx: Context): Option[Match] = x match {
+    case x: tpd.Match if x.selector.isEmpty => Some(x)
+    case _ => None
+  }
+
+  def ImplicitMatch_cases(self: Match)(implicit ctx: Context): List[CaseDef] = self.cases
+
+  def ImplicitMatch_apply(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
+    withDefaultPos(ctx => tpd.Match(tpd.EmptyTree, cases)(ctx))
+
+  def ImplicitMatch_copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImplicitMatch =
+    tpd.cpy.Match(original)(tpd.EmptyTree, cases)
+
   type Try = tpd.Try
 
   def matchTry(x: Term)(implicit ctx: Context): Option[Try] = x match {
@@ -1297,7 +1341,7 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
 
   def Position_exists(self: Position): Boolean = self.exists
 
-  def Position_sourceFile(self: Position): java.nio.file.Path = self.source.file.jpath
+  def Position_sourceFile(self: Position): SourceFile = self.source
 
   def Position_startLine(self: Position): Int = self.startLine
 
@@ -1310,6 +1354,16 @@ class KernelImpl(val rootContext: core.Contexts.Context, val rootPosition: util.
   def Position_sourceCode(self: Position): String =
     new String(self.source.content(), self.start, self.end - self.start)
 
+  //
+  // SOURCE FILES
+  //
+
+  type SourceFile = util.SourceFile
+
+  def SourceFile_jpath(self: SourceFile): java.nio.file.Path = self.file.jpath
+
+  def SourceFile_content(self: SourceFile): String = new String(self.content())
+
   //
   // COMMENTS
   //

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

@@ -78,7 +78,7 @@ class Pickler extends Phase {
       // println(i"rawBytes = \n$rawBytes%\n%") // DEBUG
       if (pickling ne noPrinter) {
         println(i"**** pickled info of $cls")
-        println(new TastyPrinter(pickler.assembleParts()).printContents())
+        println(new TastyPrinter(pickled).printContents())
       }
     }
   }

compiler/src/dotty/tools/dotc/tastyreflect/KernelImpl.scala

@@ -405,8 +405,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = {
+    debug.println(TypeComparer.explained(implicit ctx => tp1 <:< tp2))
     val res = (tp1 != nullType || tp2 == nullType) && tp1 <:< tp2
-    debug.println(s"${tp1} <:< ${tp2} = $res")
     res
   }
 

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -1382,7 +1382,7 @@ abstract class SearchHistory { outer =>
             val wideTp = tp.widenExpr
             lazy val wildTp = wildApprox(wideTp)
             if (belowByname && (wildTp <:< wildPt)) false
-            else if ((wideTp.typeSize < ptSize && wideTp.coveringSet == ptCoveringSet) || (wildTp == wildPt)) true
+            else if ((wideTp.typeSize < ptSize && wideTp.coveringSet == ptCoveringSet) || (wildTp =:= wildPt)) true
             else loop(tl, isByname(tp) || belowByname)
           }
           else loop(tl, isByname(tp) || belowByname)

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -23,8 +23,4 @@ i4006c.scala
 
 # Not sure what's wring here
 i4203.scala
-t6278-synth-def.scala
-
-# Need to print empty tree for implicit match
-i5938.scala
-i6014-gadt.scala
+t6278-synth-def.scala

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

@@ -3,13 +3,3 @@ eff-dependent.scala
 
 # It seems we still harmonize types in fromTasty. Not sure where this happens
 puzzle.scala
-
-# Need to print empty tree for implicit match
-implicitMatch.scala
-typeclass-derivation1.scala
-typeclass-derivation2.scala
-typeclass-derivation2a.scala
-typeclass-derivation3.scala
-derive-generic.scala
-deriving-interesting-prefixes.scala
-companion-loading.scala

compiler/test/dotc/pos-from-tasty.blacklist

@@ -108,6 +108,7 @@ TASTy Reflect provides the following types:
          |                             +- Lambda
          |                             +- If
          |                             +- Match
+         |                             +- ImplicitMatch
          |                             +- Try
          |                             +- Return
          |                             +- Repeated