Address review comments

Author: smarter

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

@@ -31,15 +31,16 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
    *   Does tree contain an initialization part when seen as a member of a class or trait?
    */
   def defKind(tree: Tree): FlagSet = unsplice(tree) match {
-    case EmptyTree | _: Import => NoInitsInterface
-    case tree: TypeDef => if (tree.isClassDef) NoInits else NoInitsInterface
+    case EmptyTree | _: Import =>
+      NoInitsInterface
+    case tree: TypeDef =>
+      if (tree.isClassDef) NoInits else NoInitsInterface
     case tree: DefDef =>
-      if (tree.unforcedRhs == EmptyTree)
-        (NoInitsInterface /: tree.vparamss.flatten)((fs, vparam) => fs & defKind(vparam))
-      else
-        NoInits
-    case tree: ValDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
-    case _ => EmptyFlags
+      if (tree.unforcedRhs == EmptyTree && tree.vparamss.forall(_.forall(_.unforcedRhs == EmptyTree))) NoInitsInterface else NoInits
+    case tree: ValDef =>
+      if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
+    case _ =>
+      EmptyFlags
   }
 
   def isOpAssign(tree: Tree) = unsplice(tree) match {

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

@@ -15,12 +15,21 @@ import printing.Formatting._
 object Decorators {
 
   /** Turns Strings into PreNames, adding toType/TermName methods */
-  implicit class StringDecorator(val s: String) extends AnyVal with PreName {
+  implicit class PreNamedString(val s: String) extends AnyVal with PreName {
     def toTypeName: TypeName = typeName(s)
     def toTermName: TermName = termName(s)
     def toText(printer: Printer): Text = Str(s)
   }
 
+  implicit class StringDecorator(val s: String) extends AnyVal {
+    def splitWhere(f: Char => Boolean, doDropIndex: Boolean = false): Option[(String, String)] =
+      splitAt(s.indexWhere(f), doDropIndex)
+
+    private def splitAt(idx: Int, doDropIndex: Boolean = false): Option[(String, String)] =
+      if (idx == -1) None
+      else Some((s.take(idx), s.drop(if (doDropIndex) idx + 1 else idx)))
+  }
+
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */

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

@@ -5,7 +5,7 @@ import java.security.MessageDigest
 import scala.annotation.switch
 import scala.io.Codec
 import Names._, StdNames._, Contexts._, Symbols._, Flags._
-import Decorators.StringDecorator
+import Decorators.PreNamedString
 import util.{Chars, NameTransformer}
 import Chars.isOperatorPart
 import Definitions._

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

@@ -7,7 +7,7 @@ import scala.annotation.switch
 import Names._
 import Symbols._
 import Contexts._
-import Decorators.StringDecorator
+import Decorators.PreNamedString
 import util.NameTransformer
 import scala.collection.breakOut
 

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

@@ -12,7 +12,7 @@ import scala.compat.Platform.currentTime
 import dotty.tools.io.{ ClassPath, AbstractFile }
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, util.Positions._, Names._
 import StdNames._, NameOps._
-import Decorators.{StringDecorator, StringInterpolators}
+import Decorators.{PreNamedString, StringInterpolators}
 import classfile.ClassfileParser
 import scala.util.control.NonFatal
 

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

@@ -23,7 +23,6 @@ import Decorators._
 import StdNames._
 import dotty.tools.dotc.reporting.diagnostic.messages.IdentifierExpected
 import dotty.tools.dotc.util.SourceFile
-import util.Collections._
 import util.Positions._
 import annotation.switch
 import scala.collection.mutable.ListBuffer
@@ -136,7 +135,7 @@ object JavaParsers {
       ValDef(name, tpt, EmptyTree).withMods(Modifiers(Flags.JavaDefined | Flags.ParamAccessor))
 
     def makeConstructor(formals: List[Tree], tparams: List[TypeDef], flags: FlagSet = Flags.JavaDefined) = {
-      val vparams = mapWithIndex(formals)((p, i) => makeSyntheticParam(i + 1, p))
+      val vparams = formals.zipWithIndex.map { case (p, i) => makeSyntheticParam(i + 1, p) }
       DefDef(nme.CONSTRUCTOR, tparams, List(vparams), TypeTree(), EmptyTree).withMods(Modifiers(flags))
     }
 

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

@@ -5,12 +5,12 @@ package parsing
 import scala.collection.mutable
 import scala.xml.{ EntityRef, Text }
 import core._
+import Decorators._
 import Flags.Mutable
 import Names._, StdNames._, ast.Trees._, ast.{tpd, untpd}
 import Symbols._, Contexts._
 import util.Positions._
 import Parsers.Parser
-import util.StringOps.splitWhere
 import scala.language.implicitConversions
 
 /** This class builds instance of `Tree` that represent XML.
@@ -171,7 +171,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
   }
 
   /** Returns (Some(prefix) | None, rest) based on position of ':' */
-  def splitPrefix(name: String): (Option[String], String) = splitWhere(name, _ == ':', true) match {
+  def splitPrefix(name: String): (Option[String], String) = name.splitWhere(_ == ':', doDropIndex = true) match {
     case Some((pre, rest))  => (Some(pre), rest)
     case _                  => (None, name)
   }

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

@@ -12,8 +12,6 @@ import NameOps._
 import ast._
 import ast.Trees._
 
-import util.Collections
-
 /** Provides methods to produce fully parameterized versions of instance methods,
  *  where the `this` of the enclosing class is abstracted out in an extra leading
  *  `$this` parameter and type parameters of the class become additional type
@@ -234,8 +232,8 @@ trait FullParameterization {
       fun.appliedToArgss(originalDef.vparamss.nestedMap(vparam => ref(vparam.symbol)))
     else {
       // this type could have changed on forwarding. Need to insert a cast.
-      val args = Collections.map2(originalDef.vparamss, fun.tpe.paramTypess)((vparams, paramTypes) =>
-        Collections.map2(vparams, paramTypes)((vparam, paramType) => {
+      val args = (originalDef.vparamss, fun.tpe.paramTypess).zipped.map((vparams, paramTypes) =>
+        (vparams, paramTypes).zipped.map((vparam, paramType) => {
           assert(vparam.tpe <:< paramType.widen) // type should still conform to widened type
           ref(vparam.symbol).ensureConforms(paramType)
         })

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

@@ -30,8 +30,6 @@ import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags
 
-import util.Collections
-
 /** This transform eliminates patterns. Right now it's a dummy.
  *  Awaiting the real pattern matcher.
  *  elimRepeated is required
@@ -166,7 +164,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
     }
 
     def emitValDefs: List[ValDef] = {
-      Collections.map2(lhs, rhs)((symbol, tree) => ValDef(symbol.asTerm, tree.ensureConforms(symbol.info)))
+      (lhs, rhs).zipped.map((symbol, tree) => ValDef(symbol.asTerm, tree.ensureConforms(symbol.info)))
     }
   }
   object NoRebindings extends Rebindings(Nil, Nil)
@@ -609,7 +607,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
             // only store binders actually used
             val (subPatBindersStored, subPatRefsStored) = stored.filter{case (b, _) => usedBinders(b)}.unzip
 
-            Block(Collections.map2(subPatBindersStored.toList, subPatRefsStored.toList)((bind, ref) => {
+            Block((subPatBindersStored.toList, subPatRefsStored.toList).zipped.map((bind, ref) => {
               // required in case original pattern had a more precise type
               // eg case s@"foo" =>  would be otherwise translated to s with type String instead of String("foo")
               def refTpeWiden = ref.tpe.widen

compiler/src/dotty/tools/dotc/util/Collections.scala

@@ -6,9 +6,9 @@
 package dotty.tools
 package io
 
-import dotc.util.StringOps.splitWhere
 import java.net.URL
 import scala.collection.{ mutable, immutable }
+import dotc.core.Decorators.StringDecorator
 import File.pathSeparator
 import java.net.MalformedURLException
 import Jar.isJarOrZip
@@ -238,7 +238,7 @@ abstract class ClassPath {
    * Does not support nested classes on .NET
    */
   def findClass(name: String): Option[AnyClassRep] =
-    splitWhere(name, _ == '.', true) match {
+    name.splitWhere(_ == '.', doDropIndex = true) match {
       case Some((pkg, rest)) =>
         val rep = packages find (_.name == pkg) flatMap (_ findClass rest)
         rep map {