Avoid more collection ops in frontend

Author: odersky

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

@@ -1556,7 +1556,13 @@ object SymDenotations {
           completeChildrenIn(companionClass)
           setFlag(ChildrenQueried)
 
-      annotations.collect { case Annotation.Child(child) => child }.reverse
+      /** The children recorded in `annots`, in reverse order */
+      def getChildren(annots: List[Annotation], acc: List[Symbol]): List[Symbol] = annots match
+        case Annotation.Child(child) :: annots1 => getChildren(annots1, child :: acc)
+        case _ :: annots1 => getChildren(annots1, acc)
+        case nil => acc
+
+      getChildren(annotations, Nil)
     end children
   }
 

compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala

@@ -97,14 +97,14 @@ class NameBuffer extends TastyBuffer(10000) {
     }
   }
 
-  override def assemble(): Unit = {
+  override def assemble(): Unit =
     var i = 0
-    for ((name, ref) <- nameRefs) {
+    val nr = nameRefs.iterator
+    while nr.hasNext do
+      val (name, ref) = nr.next()
       assert(ref.index == i)
       i += 1
       pickleNameContents(name)
-    }
-  }
 }
 
 object NameBuffer {

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

@@ -22,12 +22,19 @@ object SymUtils {
 
   extension (self: Symbol) {
 
-  /** All traits implemented by a class or trait except for those inherited through the superclass. */
+  /** All traits implemented by a class or trait except for those inherited
+   *  through the superclass. Traits are given in the order they appear in the
+   *  parents clause (which is the reverse of their order in baseClasses)
+   */
   def directlyInheritedTraits(using Context): List[ClassSymbol] = {
     val superCls = self.asClass.superClass
     val baseClasses = self.asClass.baseClasses
     if (baseClasses.isEmpty) Nil
-    else baseClasses.tail.takeWhile(_ ne superCls).reverse
+    else
+      def recur(bcs: List[ClassSymbol], acc: List[ClassSymbol]): List[ClassSymbol] = bcs match
+        case bc :: bcs1 => if bc eq superCls then acc else recur(bcs1, bc :: acc)
+        case nil => acc
+      recur(baseClasses.tail, Nil)
   }
 
   /** All traits implemented by a class, except for those inherited through the superclass.

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

@@ -491,10 +491,9 @@ object RefChecks {
        */
       def missingTermSymbols: List[Symbol] =
         val buf = new mutable.ListBuffer[Symbol]
-        for bc <- clazz.baseClasses
-            sym <- bc.info.decls.toList
-            if sym.is(DeferredTerm) && !isImplemented(sym) && !ignoreDeferred(sym)
-        do buf += sym
+        for bc <- clazz.baseClasses; sym <- bc.info.decls.toList do
+          if sym.is(DeferredTerm) && !isImplemented(sym) && !ignoreDeferred(sym)
+            buf += sym
         buf.toList
 
       // 2. Check that only abstract classes have deferred members

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

@@ -1224,21 +1224,24 @@ class Typer extends Namer
       }
 
     val desugared =
-      if (protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head)) {
+      if (protoFormals.length == 1 && params.length != 1 && ptIsCorrectProduct(protoFormals.head))
         val isGenericTuple =
           protoFormals.head.derivesFrom(defn.TupleClass)
           && !defn.isTupleClass(protoFormals.head.typeSymbol)
         desugar.makeTupledFunction(params, fnBody, isGenericTuple)
-      }
-      else {
-        val inferredParams: List[untpd.ValDef] =
-          for ((param, i) <- params.zipWithIndex) yield
-            if (!param.tpt.isEmpty) param
-            else cpy.ValDef(param)(
-              tpt = untpd.TypeTree(
-                inferredParamType(param, protoFormal(i)).translateFromRepeated(toArray = false)))
-        desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual)
-      }
+      else
+        def inferredParams(params: List[untpd.ValDef], idx: Int): List[untpd.ValDef] = params match
+          case param :: rest =>
+            val param1 =
+              if !param.tpt.isEmpty then param
+              else cpy.ValDef(param)(
+                tpt = untpd.TypeTree(
+                  inferredParamType(param, protoFormal(idx)).translateFromRepeated(toArray = false)))
+            param1 :: inferredParams(rest, idx + 1)
+          case nil =>
+            Nil
+        desugar.makeClosure(inferredParams(params, 0), fnBody, resultTpt, isContextual)
+
     typed(desugared, pt)
   }