Merge pull request #4264 from dotty-staging/opt/misc

Small optimizations

Author: nicolasstucki

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

@@ -771,7 +771,7 @@ object Trees {
   def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
     var buf: ListBuffer[Tree[T]] = null
     var xs = trees
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       xs.head match {
         case Thicket(elems) =>
           if (buf == null) {

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

@@ -64,7 +64,7 @@ trait Hashable {
     var h = seed
     var xs = tps
     var len = arity
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       val elemHash = typeHash(bs, xs.head)
       if (elemHash == NotCached) return NotCached
       h = hashing.mix(h, elemHash)

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

@@ -45,7 +45,7 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
   final def consistentParams(that: Signature): Boolean = {
     @tailrec def loop(names1: List[TypeName], names2: List[TypeName]): Boolean =
       if (names1.isEmpty) names2.isEmpty
-      else names2.nonEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
+      else !names2.isEmpty && consistent(names1.head, names2.head) && loop(names1.tail, names2.tail)
     loop(this.paramsSig, that.paramsSig)
   }
 

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -249,13 +249,13 @@ object Scanners {
     /** Are we directly in a string interpolation expression?
      */
     private def inStringInterpolation =
-      sepRegions.nonEmpty && sepRegions.head == STRINGLIT
+      !sepRegions.isEmpty && sepRegions.head == STRINGLIT
 
     /** Are we directly in a multiline string interpolation expression?
      *  @pre inStringInterpolation
      */
     private def inMultiLineInterpolation =
-      inStringInterpolation && sepRegions.tail.nonEmpty && sepRegions.tail.head == STRINGPART
+      inStringInterpolation && !sepRegions.tail.isEmpty && sepRegions.tail.head == STRINGPART
 
     /** read next token and return last offset
      */

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

@@ -299,7 +299,6 @@ class SuperAccessors(thisPhase: DenotTransformer) {
      */
     private def needsProtectedAccessor(sym: Symbol, pos: Position)(implicit ctx: Context): Boolean = {
       val clazz = currentClass
-      val host = hostForAccessorOf(sym, clazz)
       def accessibleThroughSubclassing =
         validCurrentClass && clazz.classInfo.selfType.derivesFrom(sym.owner) && !clazz.is(Trait)
 
@@ -311,7 +310,13 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         && (sym.enclosingPackageClass != currentClass.enclosingPackageClass)
         && (sym.enclosingPackageClass == sym.accessBoundary(sym.enclosingPackageClass))
       )
+
+      if (!isCandidate)
+        return false
+
+      val host = hostForAccessorOf(sym, clazz)
       val hostSelfType = host.classInfo.selfType
+
       def isSelfType = !(host.appliedRef <:< hostSelfType) && {
         if (hostSelfType.typeSymbol.is(JavaDefined))
           ctx.restrictionError(
@@ -326,7 +331,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         )
         true
       }
-      isCandidate && !host.is(Package) && !isSelfType && !isJavaProtected
+      !host.is(Package) && !isSelfType && !isJavaProtected
     }
 
     /** Return the innermost enclosing class C of referencingClass for which either

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

@@ -1137,12 +1137,17 @@ class Namer { typer: Typer =>
       }
 
       def cookedRhsType = deskolemize(dealiasIfUnit(widenRhs(rhsType)))
-      lazy val lhsType = fullyDefinedType(cookedRhsType, "right-hand side", mdef.pos)
+      def lhsType = fullyDefinedType(cookedRhsType, "right-hand side", mdef.pos)
       //if (sym.name.toString == "y") println(i"rhs = $rhsType, cooked = $cookedRhsType")
-      if (inherited.exists)
-        if (sym.is(Final, butNot = Method) && lhsType.isInstanceOf[ConstantType])
-          lhsType // keep constant types that fill in for a non-constant (to be revised when inline has landed).
+      if (inherited.exists) {
+        if (sym.is(Final, butNot = Method)) {
+          val tp = lhsType
+          if (tp.isInstanceOf[ConstantType])
+            tp // keep constant types that fill in for a non-constant (to be revised when inline has landed).
+          else inherited
+        }
         else inherited
+      }
       else {
         if (sym is Implicit)
           mdef match {