Merge pull request scala#3445 from retronym/topic/opt7

Grab bag of compiler optimizations

Author: gkossakowski

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -522,6 +522,8 @@ abstract class Erasure extends AddInterfaces
   class Eraser(_context: Context) extends Typer(_context) with TypeAdapter {
     val typer = this.asInstanceOf[analyzer.Typer]
 
+    override protected def stabilize(tree: Tree, pre: Type, mode: Mode, pt: Type): Tree = tree
+
     /**  Replace member references as follows:
      *
      *   - `x == y` for == in class Any becomes `x equals y` with equals in class Object.

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

@@ -788,7 +788,7 @@ trait Implicits {
         final class LocalShadower extends Shadower {
           val shadowed = util.HashSet[Name](512)
           def addInfos(infos: Infos) {
-            shadowed addEntries infos.map(_.name)
+            infos.foreach(i => shadowed.addEntry(i.name))
           }
           def isShadowed(name: Name) = shadowed(name)
         }
@@ -805,7 +805,6 @@ trait Implicits {
       private def isIneligible(info: ImplicitInfo) = (
            info.isCyclicOrErroneous
         || isView && (info.sym eq Predef_conforms)
-        || shadower.isShadowed(info.name)
         || (!context.macrosEnabled && info.sym.isTermMacro)
       )
 
@@ -814,6 +813,7 @@ trait Implicits {
       def survives(info: ImplicitInfo) = (
            !isIneligible(info)                      // cyclic, erroneous, shadowed, or specially excluded
         && isPlausiblyCompatible(info.tpe, wildPt)  // optimization to avoid matchesPt
+        && !shadower.isShadowed(info.name)          // OPT rare, only check for plausible candidates
         && matchesPt(info)                          // stable and matches expected type
       )
       /** The implicits that are not valid because they come later in the source and

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

@@ -1069,8 +1069,9 @@ trait Namers extends MethodSynthesis {
       }
 
       def overriddenSymbol(resTp: Type) = {
+        lazy val schema: Type = methodTypeSchema(resTp) // OPT create once. Must be lazy to avoid cycles in neg/t5093.scala
         intersectionType(methOwner.info.parents).nonPrivateMember(meth.name).filter { sym =>
-          sym != NoSymbol && (site.memberType(sym) matches methodTypeSchema(resTp))
+          sym != NoSymbol && (site.memberType(sym) matches schema)
         }
       }
       // TODO: see whether this or something similar would work instead:

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

@@ -46,7 +46,7 @@ trait StdAttachments {
    *  The parameter is of type `Any`, because macros can expand both into trees and into annotations.
    */
   def hasMacroExpansionAttachment(any: Any): Boolean = any match {
-    case tree: Tree => tree.attachments.get[MacroExpansionAttachment].isDefined
+    case tree: Tree => tree.hasAttachment[MacroExpansionAttachment]
     case _ => false
   }
 
@@ -96,7 +96,7 @@ trait StdAttachments {
    */
   def isMacroExpansionSuppressed(tree: Tree): Boolean =
     (  settings.Ymacroexpand.value == settings.MacroExpand.None // SI-6812
-    || tree.attachments.get[SuppressMacroExpansionAttachment.type].isDefined
+    || tree.hasAttachment[SuppressMacroExpansionAttachment.type]
     || (tree match {
         // we have to account for the fact that during typechecking an expandee might become wrapped,
         // i.e. surrounded by an inferred implicit argument application or by an inferred type argument application.
@@ -150,7 +150,7 @@ trait StdAttachments {
   /** Determines whether a tree should or should not be adapted,
    *  because someone has put MacroImplRefAttachment on it.
    */
-  def isMacroImplRef(tree: Tree): Boolean = tree.attachments.get[MacroImplRefAttachment.type].isDefined
+  def isMacroImplRef(tree: Tree): Boolean = tree.hasAttachment[MacroImplRefAttachment.type]
 
   /** Since mkInvoke, the applyDynamic/selectDynamic/etc desugarer, is disconnected
    *  from typedNamedApply, the applyDynamicNamed argument rewriter, the latter

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

@@ -579,7 +579,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
      *  3. Turn tree type into stable type if possible and required by context.
      *  4. Give getClass calls a more precise type based on the type of the target of the call.
      */
-    private def stabilize(tree: Tree, pre: Type, mode: Mode, pt: Type): Tree = {
+    protected def stabilize(tree: Tree, pre: Type, mode: Mode, pt: Type): Tree = {
+
       // Side effect time! Don't be an idiot like me and think you
       // can move "val sym = tree.symbol" before this line, because
       // inferExprAlternative side-effects the tree's symbol.
@@ -992,7 +993,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       def adaptMismatchedSkolems() = {
         def canIgnoreMismatch = (
              !context.reportErrors && isPastTyper
-          || tree.attachments.get[MacroExpansionAttachment].isDefined
+          || tree.hasAttachment[MacroExpansionAttachment]
         )
         def bound = pt match {
           case ExistentialType(qs, _) => qs
@@ -2232,14 +2233,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               DeprecatedParamNameError(p, n)
           }
         }
-      }
-      if (meth.isStructuralRefinementMember)
-        checkMethodStructuralCompatible(ddef)
+        if (meth.isStructuralRefinementMember)
+          checkMethodStructuralCompatible(ddef)
 
-      if (meth.isImplicit && !meth.isSynthetic) meth.info.paramss match {
-        case List(param) :: _ if !param.isImplicit =>
-          checkFeature(ddef.pos, ImplicitConversionsFeature, meth.toString)
-        case _ =>
+        if (meth.isImplicit && !meth.isSynthetic) meth.info.paramss match {
+          case List(param) :: _ if !param.isImplicit =>
+            checkFeature(ddef.pos, ImplicitConversionsFeature, meth.toString)
+          case _ =>
+        }
       }
 
       treeCopy.DefDef(ddef, typedMods, ddef.name, tparams1, vparamss1, tpt1, rhs1) setType NoType

src/library/scala/collection/immutable/Set.scala

@@ -82,6 +82,16 @@ object Set extends ImmutableSetFactory[Set] {
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1)
     }
+    override def exists(f: A => Boolean): Boolean = {
+      f(elem1)
+    }
+    override def forall(f: A => Boolean): Boolean = {
+      f(elem1)
+    }
+    override def find(f: A => Boolean): Option[A] = {
+      if (f(elem1)) Some(elem1)
+      else None
+    }
   }
 
   /** An optimized representation for immutable sets of size 2 */
@@ -102,6 +112,17 @@ object Set extends ImmutableSetFactory[Set] {
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2)
     }
+    override def exists(f: A => Boolean): Boolean = {
+      f(elem1) || f(elem2)
+    }
+    override def forall(f: A => Boolean): Boolean = {
+      f(elem1) && f(elem2)
+    }
+    override def find(f: A => Boolean): Option[A] = {
+      if (f(elem1)) Some(elem1)
+      else if (f(elem2)) Some(elem2)
+      else None
+    }
   }
 
   /** An optimized representation for immutable sets of size 3 */
@@ -123,6 +144,18 @@ object Set extends ImmutableSetFactory[Set] {
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2); f(elem3)
     }
+    override def exists(f: A => Boolean): Boolean = {
+      f(elem1) || f(elem2) || f(elem3)
+    }
+    override def forall(f: A => Boolean): Boolean = {
+      f(elem1) && f(elem2) && f(elem3)
+    }
+    override def find(f: A => Boolean): Option[A] = {
+      if (f(elem1)) Some(elem1)
+      else if (f(elem2)) Some(elem2)
+      else if (f(elem3)) Some(elem3)
+      else None
+    }
   }
 
   /** An optimized representation for immutable sets of size 4 */
@@ -145,6 +178,19 @@ object Set extends ImmutableSetFactory[Set] {
     override def foreach[U](f: A =>  U): Unit = {
       f(elem1); f(elem2); f(elem3); f(elem4)
     }
+    override def exists(f: A => Boolean): Boolean = {
+      f(elem1) || f(elem2) || f(elem3) || f(elem4)
+    }
+    override def forall(f: A => Boolean): Boolean = {
+      f(elem1) && f(elem2) && f(elem3) && f(elem4)
+    }
+    override def find(f: A => Boolean): Option[A] = {
+      if (f(elem1)) Some(elem1)
+      else if (f(elem2)) Some(elem2)
+      else if (f(elem3)) Some(elem3)
+      else if (f(elem4)) Some(elem4)
+      else None
+    }
   }
 }
 

src/reflect/scala/reflect/internal/TreeInfo.scala

@@ -284,17 +284,17 @@ abstract class TreeInfo {
   /** Is tree a self constructor call this(...)? I.e. a call to a constructor of the
    *  same object?
    */
-  def isSelfConstrCall(tree: Tree): Boolean = tree match {
-    case Applied(Ident(nme.CONSTRUCTOR), _, _)           => true
-    case Applied(Select(This(_), nme.CONSTRUCTOR), _, _) => true
-    case _                                               => false
+  def isSelfConstrCall(tree: Tree): Boolean = dissectApplied(tree).core match {
+    case Ident(nme.CONSTRUCTOR)           => true
+    case Select(This(_), nme.CONSTRUCTOR) => true
+    case _                                => false
   }
 
   /** Is tree a super constructor call?
    */
-  def isSuperConstrCall(tree: Tree): Boolean = tree match {
-    case Applied(Select(Super(_, _), nme.CONSTRUCTOR), _, _) => true
-    case _                                                   => false
+  def isSuperConstrCall(tree: Tree): Boolean = dissectApplied(tree).core match {
+    case Select(Super(_, _), nme.CONSTRUCTOR) => true
+    case _                                    => false
   }
 
   /**
@@ -848,8 +848,10 @@ abstract class TreeInfo {
       case _ => false
     })
 
-  def isMacroApplication(tree: Tree): Boolean =
-    !tree.isDef && tree.symbol != null && tree.symbol.isTermMacro && !tree.symbol.isErroneous
+  def isMacroApplication(tree: Tree): Boolean = !tree.isDef && {
+    val sym = tree.symbol
+    sym != null && sym.isTermMacro && !sym.isErroneous
+  }
 
   def isMacroApplicationOrBlock(tree: Tree): Boolean = tree match {
     case Block(_, expr) => isMacroApplicationOrBlock(expr)

src/reflect/scala/reflect/internal/tpe/TypeMaps.scala

@@ -861,7 +861,7 @@ private[internal] trait TypeMaps {
   class InstantiateDependentMap(params: List[Symbol], actuals0: List[Type]) extends TypeMap with KeepOnlyTypeConstraints {
     private val actuals      = actuals0.toIndexedSeq
     private val existentials = new Array[Symbol](actuals.size)
-    def existentialsNeeded: List[Symbol] = existentials.filter(_ ne null).toList
+    def existentialsNeeded: List[Symbol] = existentials.iterator.filter(_ ne null).toList
 
     private object StableArg {
       def unapply(param: Symbol) = Arg unapply param map actuals filter (tp =>

src/reflect/scala/reflect/macros/Attachments.scala

@@ -43,7 +43,7 @@ abstract class Attachments { self =>
 
   /** Check underlying payload contains an instance of type `T`. */
   def contains[T: ClassTag]: Boolean =
-    all exists matchesTag[T]
+    !isEmpty && (all exists matchesTag[T])
 
   /** Creates a copy of this attachment with the payload slot of T added/updated with the provided value.
    *  Replaces an existing payload of the same type, if exists.
@@ -57,11 +57,14 @@ abstract class Attachments { self =>
     if (newAll.isEmpty) pos.asInstanceOf[Attachments { type Pos = self.Pos }]
     else new NonemptyAttachments[Pos](this.pos, newAll)
   }
+
+  def isEmpty: Boolean = true
 }
 
 // SI-7018: This used to be an inner class of `Attachments`, but that led to a memory leak in the
 // IDE via $outer pointers.
 private final class NonemptyAttachments[P >: Null](override val pos: P, override val all: Set[Any]) extends Attachments {
   type Pos = P
   def withPos(newPos: Pos) = new NonemptyAttachments(newPos, all)
+  override def isEmpty: Boolean = false
 }