Outline Typing

src/compiler/scala/tools/nsc/classpath/ZipAndJarFileLookupFactory.scala

@@ -197,35 +197,49 @@ final class FileBasedCache[T] {
   private case class Stamp(lastModified: FileTime, size: Long, fileKey: Object)
   private case class Entry(stamps: Seq[Stamp], t: T) {
     val referenceCount: AtomicInteger = new AtomicInteger(1)
+    var timerTask: TimerTask = null
+    def cancelTimer(): Unit = {
+      timerTask match {
+        case null =>
+        case t => t.cancel()
+      }
+    }
   }
   private val cache = collection.mutable.Map.empty[Seq[Path], Entry]
 
-  private def referenceCountDecrementer(e: Entry, paths: Seq[Path]): Closeable = new Closeable {
-    var closed = false
-    override def close(): Unit = {
-      if (!closed) {
-        closed = true
-        val count = e.referenceCount.decrementAndGet()
-        if (count == 0) {
-          e.t match {
-            case cl: Closeable =>
-              FileBasedCache.timer match {
-                case Some(timer) =>
-                  val task = new TimerTask {
-                    override def run(): Unit = {
-                      cache.synchronized {
-                        if (e.referenceCount.compareAndSet(0, -1)) {
-                          cache.remove(paths)
-                          cl.close()
+  private def referenceCountDecrementer(e: Entry, paths: Seq[Path]): Closeable = {
+    // Cancel the deferred close timer (if any) that was started when the reference count
+    // last dropped to zero.
+    e.cancelTimer()
+
+    new Closeable {
+      var closed = false
+      override def close(): Unit = {
+        if (!closed) {
+          closed = true
+          val count = e.referenceCount.decrementAndGet()
+          if (count == 0) {
+            e.t match {
+              case cl: Closeable =>
+                FileBasedCache.timer match {
+                  case Some(timer) =>
+                    val task = new TimerTask {
+                      override def run(): Unit = {
+                        cache.synchronized {
+                          if (e.referenceCount.compareAndSet(0, -1)) {
+                            cache.remove(paths)
+                            cl.close()
+                          }
                         }
                       }
                     }
-                  }
-                  timer.schedule(task, FileBasedCache.deferCloseMs.toLong)
-                case None =>
-                  cl.close()
-              }
-            case _ =>
+                    e.timerTask = task
+                    timer.schedule(task, FileBasedCache.deferCloseMs.toLong)
+                  case None =>
+                    cl.close()
+                }
+              case _ =>
+            }
           }
         }
       }

src/compiler/scala/tools/nsc/plugins/Plugins.scala

@@ -167,38 +167,4 @@ trait Plugins { global: Global =>
     (for (plug <- roughPluginsList ; help <- plug.optionsHelp) yield {
       "\nOptions for plugin '%s':\n%s\n".format(plug.name, help)
     }).mkString
-
-  /** Obtains a `ClassLoader` instance used for macro expansion.
-    *
-    *  By default a new `ScalaClassLoader` is created using the classpath
-    *  from global and the classloader of self as parent.
-    *
-    *  Mirrors with runtime definitions (e.g. Repl) need to adjust this method.
-    */
-  protected def findMacroClassLoader(): ClassLoader = {
-    val classpath: Seq[URL] = if (settings.YmacroClasspath.isSetByUser) {
-      for {
-        file <- scala.tools.nsc.util.ClassPath.expandPath(settings.YmacroClasspath.value, true)
-        af <- Option(nsc.io.AbstractFile getDirectory file)
-      } yield af.file.toURI.toURL
-    } else global.classPath.asURLs
-    def newLoader: () => ScalaClassLoader.URLClassLoader = () => {
-      analyzer.macroLogVerbose("macro classloader: initializing from -cp: %s".format(classpath))
-      ScalaClassLoader.fromURLs(classpath, getClass.getClassLoader)
-    }
-
-    val policy = settings.YcacheMacroClassLoader.value
-    val cache = Macros.macroClassLoadersCache
-    val disableCache = policy == settings.CachePolicy.None.name
-    val checkStamps = policy == settings.CachePolicy.LastModified.name
-    cache.checkCacheability(classpath, checkStamps, disableCache) match {
-      case Left(msg) =>
-        analyzer.macroLogVerbose(s"macro classloader: $msg.")
-        val loader = newLoader()
-        closeableRegistry.registerClosable(loader)
-        loader
-      case Right(paths) =>
-        cache.getOrCreate(paths, newLoader, closeableRegistry, checkStamps)
-    }
-  }
 }

src/compiler/scala/tools/nsc/typechecker/Analyzer.scala

@@ -112,11 +112,13 @@ trait Analyzer extends AnyRef
         try {
           val typer = newTyper(rootContext(unit))
           unit.body = typer.typed(unit.body)
-          for (workItem <- unit.toCheck) workItem()
-          if (settings.warnUnusedImport)
-            warnUnusedImports(unit)
-          if (settings.warnUnused.isSetByUser)
-            new checkUnused(typer).apply(unit)
+          if (!settings.Youtline.value) {
+            for (workItem <- unit.toCheck) workItem()
+            if (settings.warnUnusedImport)
+              warnUnusedImports(unit)
+            if (settings.warnUnused.isSetByUser)
+              new checkUnused(typer).apply(unit)
+          }
         }
         finally {
           unit.toCheck.clear()

src/compiler/scala/tools/nsc/typechecker/Contexts.scala

@@ -1532,10 +1532,13 @@ trait Contexts { self: Analyzer =>
       var selectors = tree.selectors
       @inline def current = selectors.head
       while ((selectors ne Nil) && result == NoSymbol) {
-        if (current.rename == name.toTermName)
+        def sameName(name: Name, other: Name) = {
+          (name eq other) || (name ne null) && name.start == other.start && name.length == other.length
+        }
+        if (sameName(current.rename, name))
           result = qual.tpe.nonLocalMember( // new to address #2733: consider only non-local members for imports
             if (name.isTypeName) current.name.toTypeName else current.name)
-        else if (current.name == name.toTermName)
+        else if (sameName(current.name, name))
           renamed = true
         else if (current.name == nme.WILDCARD && !renamed && !requireExplicit)
           result = qual.tpe.nonLocalMember(name)

src/compiler/scala/tools/nsc/typechecker/Namers.scala

@@ -1311,7 +1311,11 @@ trait Namers extends MethodSynthesis {
 
       val resTpGiven =
         if (tpt.isEmpty) WildcardType
-        else typer.typedType(tpt).tpe
+        else {
+          val tptTyped = typer.typedType(tpt)
+          context.unit.transformed(tpt) = tptTyped
+          tptTyped.tpe
+        }
 
 
       // ignore missing types unless we can look to overridden method to recover the missing information
@@ -1723,7 +1727,11 @@ trait Namers extends MethodSynthesis {
 
             tptFromRhsUnderPt
           }
-        } else typer.typedType(tpt).tpe
+        } else {
+          val tptTyped = typer.typedType(tpt)
+          context.unit.transformed(tpt) = tptTyped
+          tptTyped.tpe
+        }
 
 //      println(s"val: $result / ${vdef.tpt.tpe} / ")
 

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -1604,7 +1604,8 @@ abstract class RefChecks extends Transform {
               if qual1.symbol == rd.StringContext_apply &&
                 treeInfo.isQualifierSafeToElide(qual) &&
                 lits.forall(lit => treeInfo.isLiteralString(lit)) &&
-                lits.length == (args.length + 1) =>
+                lits.length == (args.length + 1) &&
+                args.lengthCompare(64) <= 0 => // TODO make more robust to large input so that we can drop this condition, chunk the concatenations in manageable batches
               val isRaw = sym == rd.StringContext_raw
               if (isRaw) Some((lits, args))
               else {

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -2087,7 +2087,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       } else typedModifiers(vdef.mods)
 
       sym.annotations.map(_.completeInfo())
-      val tpt1 = checkNoEscaping.privates(this, sym, typedType(vdef.tpt))
+      val tpt1 = checkNoEscaping.privates(this, sym, transformedOr(vdef.tpt, typedType(vdef.tpt)))
       checkNonCyclic(vdef, tpt1)
 
       // allow trait accessors: it's the only vehicle we have to hang on to annotations that must be passed down to
@@ -2315,7 +2315,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           if (isRepeatedParamType(vparam1.symbol.tpe))
             StarParamNotLastError(vparam1)
 
-        val tpt1 = checkNoEscaping.privates(this, meth, typedType(ddef.tpt))
+        val tpt1 = checkNoEscaping.privates(this, meth, transformedOr(ddef.tpt, typedType(ddef.tpt)))
         checkNonCyclic(ddef, tpt1)
         ddef.tpt.setType(tpt1.tpe)
         val typedMods = typedModifiers(ddef.mods)
@@ -5945,14 +5945,21 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     final def transformedOrTyped(tree: Tree, mode: Mode, pt: Type): Tree = {
       lookupTransformed(tree) match {
         case Some(tree1) => tree1
-        case _           => typed(tree, mode, pt)
+        case _           => if (canSkipRhs(tree)) EmptyTree else typed(tree, mode, pt)
       }
     }
     final def lookupTransformed(tree: Tree): Option[Tree] =
       if (phase.erasedTypes) None // OPT save the hashmap lookup in erasure type and beyond
       else transformed remove tree
-  }
 
+    private final def canSkipRhs(tree: Tree) = settings.Youtline.value && !tree.exists {
+      case Super(qual, mix) =>
+        // conservative approximation of method bodies that may give rise to super accessors which must be
+        // stored in pickle.
+        context.owner.enclClass.isTrait || mix != tpnme.EMPTY
+      case _ => false
+    }
+  }
 
   /** Finish computation of param aliases after typechecking is completed */
   final def finishComputeParamAlias(): Unit = {
@@ -5981,6 +5988,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     }
     superConstructorCalls.clear()
   }
+
 }
 
 trait TypersStats {

src/intellij/scala.ipr.SAMPLE

@@ -363,7 +363,7 @@
         <root url="jar://$USER_HOME$/.ivy2/cache/org.scala-sbt/completion/jars/completion-0.13.18.jar!/" />
         <root url="jar://$USER_HOME$/.ivy2/cache/org.scala-sbt/collections/jars/collections-0.13.18.jar!/" />
         <root url="jar://$USER_HOME$/.ivy2/cache/jline/jline/jars/jline-2.13.jar!/" />
-        <root url="jar://$USER_HOME$/.ivy2/cache/org.fusesource.jansi/jansi/jars/jansi-1.11.jar!/" />
+        <root url="jar://$USER_HOME$/.ivy2/cache/org.fusesource.jansi/jansi/jars/jansi-1.12.jar!/" />
         <root url="jar://$USER_HOME$/.ivy2/cache/org.scala-sbt/api/jars/api-0.13.18.jar!/" />
         <root url="jar://$USER_HOME$/.ivy2/cache/org.scala-sbt/classfile/jars/classfile-0.13.18.jar!/" />
         <root url="jar://$USER_HOME$/.ivy2/cache/org.scala-sbt/logging/jars/logging-0.13.18.jar!/" />