Avoid conflict with String's apply.

This brought to light that Name extends (Int => Char), and
that small convenience was not paying for itself.  I updated
the places taking advantage of it to use Name#charAt.

8 files changed, 31 insertions, 31 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala
index 316faba6e2..b545140c4a 100755
--- a/src/compiler/scala/tools/nsc/ast/DocComments.scala
+++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala
@@ -522,7 +522,7 @@ trait DocComments { self: Global =>
 
       val substAliases = new TypeMap {
         def apply(tp: Type) = mapOver(tp) match {
-          case tp1 @ TypeRef(pre, sym, args) if (sym.name.length > 1 && sym.name(0) == '$') =>
+          case tp1 @ TypeRef(pre, sym, args) if (sym.name.length > 1 && sym.name.startChar == '$') =>
             subst(sym, aliases, aliasExpansions) match {
               case TypeRef(pre1, sym1, _) =>
                 typeRef(pre1, sym1, args)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 3232bde3b4..e0c9631246 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -763,7 +763,7 @@ self =>
     def precedence(operator: Name): Int =
       if (operator eq nme.ERROR) -1
       else {
-        val firstCh = operator(0)
+        val firstCh = operator.startChar
         if (isScalaLetter(firstCh)) 1
         else if (nme.isOpAssignmentName(operator)) 0
         else firstCh match {
diff --git a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
index 73b5a752b4..a37fdc3ed1 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala
@@ -778,7 +778,7 @@ trait JavaScanners extends ast.parser.ScannersCommon {
      */
     def intVal(negated: Boolean): Long = {
       if (token == CHARLIT && !negated) {
-        if (name.length > 0) name(0) else 0
+        if (name.length > 0) name.charAt(0) else 0
       } else {
         var value: Long = 0
         val divider = if (base == 10) 1 else 2
@@ -787,7 +787,7 @@ trait JavaScanners extends ast.parser.ScannersCommon {
         var i = 0
         val len = name.length
         while (i < len) {
-          val d = digit2int(name(i), base)
+          val d = digit2int(name.charAt(i), base)
           if (d < 0) {
             syntaxError("malformed integer number")
             return 0
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index e6499c05a6..86f9d38203 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -307,7 +307,7 @@ abstract class ClassfileParser {
         val start = starts(index)
         if (in.buf(start).toInt != CONSTANT_CLASS) errorBadTag(start)
         val name = getExternalName(in.getChar(start + 1))
-        if (name(0) == ARRAY_TAG) {
+        if (name.charAt(0) == ARRAY_TAG) {
           c = sigToType(null, name)
           values(index) = c
         } else {
@@ -667,16 +667,16 @@ abstract class ClassfileParser {
     var index = 0
     val end = sig.length
     def accept(ch: Char) {
-      assert(sig(index) == ch, (sig(index), ch))
+      assert(sig.charAt(index) == ch, (sig.charAt(index), ch))
       index += 1
     }
     def subName(isDelimiter: Char => Boolean): Name = {
       val start = index
-      while (!isDelimiter(sig(index))) { index += 1 }
+      while (!isDelimiter(sig.charAt(index))) { index += 1 }
       sig.subName(start, index)
     }
     def sig2type(tparams: immutable.Map[Name,Symbol], skiptvs: Boolean): Type = {
-      val tag = sig(index); index += 1
+      val tag = sig.charAt(index); index += 1
       tag match {
         case BYTE_TAG   => definitions.ByteClass.tpe
         case CHAR_TAG   => definitions.CharClass.tpe
@@ -697,12 +697,12 @@ abstract class ClassfileParser {
           def processClassType(tp: Type): Type = tp match {
             case TypeRef(pre, classSym, args) =>
               val existentials = new ListBuffer[Symbol]()
-              if (sig(index) == '<') {
+              if (sig.charAt(index) == '<') {
                 accept('<')
                 val xs = new ListBuffer[Type]()
                 var i = 0
-                while (sig(index) != '>') {
-                  sig(index) match {
+                while (sig.charAt(index) != '>') {
+                  sig.charAt(index) match {
                     case variance @ ('+' | '-' | '*') =>
                       index += 1
                       val bounds = variance match {
@@ -738,14 +738,14 @@ abstract class ClassfileParser {
                 res
               }
             case tp =>
-              assert(sig(index) != '<', tp)
+              assert(sig.charAt(index) != '<', tp)
               tp
           }
 
           val classSym = classNameToSymbol(subName(c => c == ';' || c == '<'))
           assert(!classSym.isOverloaded, classSym.alternatives)
           var tpe = processClassType(processInner(classSym.tpe))
-          while (sig(index) == '.') {
+          while (sig.charAt(index) == '.') {
             accept('.')
             val name = subName(c => c == ';' || c == '<' || c == '.').toTypeName
             val clazz = tpe.member(name)
@@ -754,7 +754,7 @@ abstract class ClassfileParser {
           accept(';')
           tpe
         case ARRAY_TAG =>
-          while ('0' <= sig(index) && sig(index) <= '9') index += 1
+          while ('0' <= sig.charAt(index) && sig.charAt(index) <= '9') index += 1
           var elemtp = sig2type(tparams, skiptvs)
           // make unbounded Array[T] where T is a type variable into Array[T with Object]
           // (this is necessary because such arrays have a representation which is incompatible
@@ -771,7 +771,7 @@ abstract class ClassfileParser {
           // we need a method symbol. given in line 486 by calling getType(methodSym, ..)
           assert(sym ne null, sig)
           val paramtypes = new ListBuffer[Type]()
-          while (sig(index) != ')') {
+          while (sig.charAt(index) != ')') {
             paramtypes += objToAny(sig2type(tparams, skiptvs))
           }
           index += 1
@@ -791,9 +791,9 @@ abstract class ClassfileParser {
 
     def sig2typeBounds(tparams: immutable.Map[Name, Symbol], skiptvs: Boolean): Type = {
       val ts = new ListBuffer[Type]
-      while (sig(index) == ':') {
+      while (sig.charAt(index) == ':') {
         index += 1
-        if (sig(index) != ':') // guard against empty class bound
+        if (sig.charAt(index) != ':') // guard against empty class bound
           ts += objToAny(sig2type(tparams, skiptvs))
       }
       TypeBounds.upper(intersectionType(ts.toList, sym))
@@ -801,11 +801,11 @@ abstract class ClassfileParser {
 
     var tparams = classTParams
     val newTParams = new ListBuffer[Symbol]()
-    if (sig(index) == '<') {
+    if (sig.charAt(index) == '<') {
       assert(sym != null, sig)
       index += 1
       val start = index
-      while (sig(index) != '>') {
+      while (sig.charAt(index) != '>') {
         val tpname = subName(':'.==).toTypeName
         val s = sym.newTypeParameter(tpname)
         tparams = tparams + (tpname -> s)
@@ -813,7 +813,7 @@ abstract class ClassfileParser {
         newTParams += s
       }
       index = start
-      while (sig(index) != '>') {
+      while (sig.charAt(index) != '>') {
         val tpname = subName(':'.==).toTypeName
         val s = tparams(tpname)
         s.setInfo(sig2typeBounds(tparams, false))
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index 95d0369707..7bd5f4caeb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -540,7 +540,7 @@ trait MethodSynthesis {
       val ValDef(mods, name, _, _) = tree
       val beans = beanAccessorsFromNames(tree)
       if (beans.nonEmpty) {
-        if (!name(0).isLetter)
+        if (!name.charAt(0).isLetter)
           BeanPropertyAnnotationFieldWithoutLetterError(tree)
         else if (mods.isPrivate)  // avoids name clashes with private fields in traits
           BeanPropertyAnnotationPrivateFieldError(tree)
diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala
index 3c0848f77f..20da38fd63 100644
--- a/src/reflect/scala/reflect/internal/Names.scala
+++ b/src/reflect/scala/reflect/internal/Names.scala
@@ -145,7 +145,7 @@ trait Names extends api.Names with LowPriorityNames {
    *  or Strings as Names.  Give names the key functions the absence of which
    *  make people want Strings all the time.
    */
-  sealed abstract class Name(protected val index: Int, protected val len: Int) extends NameApi with Function1[Int, Char] {
+  sealed abstract class Name(protected val index: Int, protected val len: Int) extends NameApi {
     type ThisNameType >: Null <: Name
     protected[this] def thisName: ThisNameType
 
@@ -226,7 +226,7 @@ trait Names extends api.Names with LowPriorityNames {
     }
 
     /** @return the i'th Char of this name */
-    final def apply(i: Int): Char = chrs(index + i)
+    final def charAt(i: Int): Char = chrs(index + i)
 
     /** @return the index of first occurrence of char c in this name, length if not found */
     final def pos(c: Char): Int = pos(c, 0)
@@ -355,8 +355,8 @@ trait Names extends api.Names with LowPriorityNames {
     /** Some thoroughly self-explanatory convenience functions.  They
      *  assume that what they're being asked to do is known to be valid.
      */
-    final def startChar: Char                   = apply(0)
-    final def endChar: Char                     = apply(len - 1)
+    final def startChar: Char                   = this charAt 0
+    final def endChar: Char                     = this charAt len - 1
     final def startsWith(char: Char): Boolean   = len > 0 && startChar == char
     final def startsWith(name: String): Boolean = startsWith(newTermName(name))
     final def endsWith(char: Char): Boolean     = len > 0 && endChar == char
@@ -380,7 +380,7 @@ trait Names extends api.Names with LowPriorityNames {
       val cs = new Array[Char](len)
       var i = 0
       while (i < len) {
-        val ch = this(i)
+        val ch = charAt(i)
         cs(i) = if (ch == from) to else ch
         i += 1
       }
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 51dd309a61..165e04863c 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -374,9 +374,9 @@ trait StdNames {
     */
     def originalName(name: Name): Name = {
       var i = name.length
-      while (i >= 2 && !(name(i - 1) == '$' && name(i - 2) == '$')) i -= 1
+      while (i >= 2 && !(name.charAt(i - 1) == '$' && name.charAt(i - 2) == '$')) i -= 1
       if (i >= 2) {
-        while (i >= 3 && name(i - 3) == '$') i -= 1
+        while (i >= 3 && name.charAt(i - 3) == '$') i -= 1
         name.subName(i, name.length)
       } else name
     }
@@ -455,10 +455,10 @@ trait StdNames {
     // Otherwise return the argument.
     def stripAnonNumberSuffix(name: Name): Name = {
       var pos = name.length
-      while (pos > 0 && name(pos - 1).isDigit)
+      while (pos > 0 && name.charAt(pos - 1).isDigit)
       pos -= 1
 
-      if (pos <= 0 || pos == name.length || name(pos - 1) != '$') name
+      if (pos <= 0 || pos == name.length || name.charAt(pos - 1) != '$') name
       else name.subName(0, pos - 1)
     }
 
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 698d219634..745065b024 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -316,7 +316,7 @@ abstract class TreeInfo {
 
   /** Is name a variable name? */
   def isVariableName(name: Name): Boolean = {
-    val first = name(0)
+    val first = name.startChar
     ((first.isLower && first.isLetter) || first == '_') && !reserved(name)
   }