Skip to content

Commit c1460f5

Browse files
retronymretronym
committed
WIP try harder to typecheck provided args
If we fail with a "not enough args" error, but the pre-selected function resolved to a non-overloaded symbol, we should try to typecheck the given arguments.
1 parent c460f56 commit c1460f5

File tree

2 files changed

+305
-7
lines changed

2 files changed

+305
-7
lines changed

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

Lines changed: 16 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -3147,10 +3147,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
31473147
}
31483148

31493149
def doTypedApply(tree: Tree, fun0: Tree, args: List[Tree], mode: Mode, pt: Type): Tree = {
3150-
// TODO_NMT: check the assumption that args nonEmpty
3151-
def duplErrTree = setError(treeCopy.Apply(tree, fun0, args))
3152-
def duplErrorTree(err: AbsTypeError) = { issue(err); duplErrTree }
3153-
31543150
def preSelectOverloaded(fun: Tree): Tree = {
31553151
if (fun.hasSymbolField && fun.symbol.isOverloaded) {
31563152
// remove alternatives with wrong number of parameters without looking at types.
@@ -3194,6 +3190,19 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
31943190

31953191
val fun = preSelectOverloaded(fun0)
31963192

3193+
// TODO_NMT: check the assumption that args nonEmpty
3194+
def duplErrTree = {
3195+
fun.tpe match {
3196+
case MethodType(params, _) =>
3197+
val paramTypes = params.map(_.tpe)
3198+
val args1 = typedArgsForFormals(args, paramTypes, mode)
3199+
setError(treeCopy.Apply(tree, fun0, args1))
3200+
case _ =>
3201+
setError(treeCopy.Apply(tree, fun0, args))
3202+
}
3203+
}
3204+
def duplErrorTree(err: AbsTypeError) = { issue(err); duplErrTree }
3205+
31973206
fun.tpe match {
31983207
case OverloadedType(pre, alts) =>
31993208
def handleOverloaded = {
@@ -3362,7 +3371,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
33623371
doTypedApply(tree, if (blockIsEmpty) fun else fun1, allArgs, mode, pt)
33633372
} else {
33643373
rollbackNamesDefaultsOwnerChanges()
3365-
tryTupleApply orElse duplErrorTree(NotEnoughArgsError(tree, fun, missing))
3374+
tryTupleApply orElse {
3375+
duplErrorTree(NotEnoughArgsError(tree, fun, missing))
3376+
}
33663377
}
33673378
}
33683379
}

‎test/files/presentation/completion.check

Lines changed: 289 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,293 @@ reload: Completion.scala
33
askTypeCompletion at Completion.scala(7,25)
44
================================================================================
55
[response] askTypeCompletion at (7,25)
6-
retrieved 0 members
7-
6+
retrieved 305 members
7+
[inaccessible] override protected[this] def newBuilder: StringBuilder
8+
[inaccessible] override protected[this] def parCombiner: scala.collection.parallel.Combiner[Char,scala.collection.parallel.ParSeq[Char]]
9+
[inaccessible] override protected[this] def thisCollection: scala.collection.immutable.WrappedString
10+
[inaccessible] override protected[this] def toCollection(repr: String): scala.collection.immutable.WrappedString
11+
[inaccessible] override protected[this] def toCollection(repr: scala.collection.immutable.WrappedString): scala.collection.immutable.WrappedString
12+
[inaccessible] private[package lang] def getChars(x$1: Array[Char],x$2: Int): Unit
13+
[inaccessible] private[package scala] def sliceWithKnownBound(from: Int,until: Int): String
14+
[inaccessible] private[package scala] def sliceWithKnownDelta(from: Int,until: Int,delta: Int): String
15+
[inaccessible] protected class Elements extends AbstractIterator[Char] with BufferedIterator[Char] with Serializable
16+
[inaccessible] protected[package lang] def clone(): Object
17+
[inaccessible] protected[package lang] def finalize(): Unit
18+
[inaccessible] protected[this] def reversed: List[Char]
19+
[inaccessible] protected[this] type Self = String
20+
class WithFilter extends FilterMonadic[Char,String]
21+
def *(n: Int): String
22+
def +(other: String): String
23+
def ++:[B >: Char, That](that: Traversable[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
24+
def ++:[B >: Char, That](that: Traversable[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
25+
def ++:[B >: Char, That](that: scala.collection.TraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
26+
def ++:[B >: Char, That](that: scala.collection.TraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
27+
def ++[B >: Char, That](that: scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
28+
def ++[B >: Char, That](that: scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
29+
def +:[B >: Char, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
30+
def +:[B >: Char, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
31+
def ->[B](y: B): (String, B)
32+
def /:[B](z: B)(op: (B, Char) => B): B
33+
def :+[B >: Char, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
34+
def :+[B >: Char, That](elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
35+
def :\[B](z: B)(op: (Char, B) => B): B
36+
def <(that: String): Boolean
37+
def <=(that: String): Boolean
38+
def >(that: String): Boolean
39+
def >=(that: String): Boolean
40+
def addString(b: StringBuilder): StringBuilder
41+
def addString(b: StringBuilder,sep: String): StringBuilder
42+
def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder
43+
def aggregate[B](z: => B)(seqop: (B, Char) => B,combop: (B, B) => B): B
44+
def applyOrElse[A1 <: Int, B1 >: Char](x: A1,default: A1 => B1): B1
45+
def capitalize: String
46+
def charAt(x$1: Int): Char
47+
def codePointAt(x$1: Int): Int
48+
def codePointBefore(x$1: Int): Int
49+
def codePointCount(x$1: Int,x$2: Int): Int
50+
def collectFirst[B](pf: PartialFunction[Char,B]): Option[B]
51+
def collect[B, That](pf: PartialFunction[Char,B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
52+
def collect[B, That](pf: PartialFunction[Char,B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
53+
def combinations(n: Int): Iterator[String]
54+
def compareTo(x$1: String): Int
55+
def compareToIgnoreCase(x$1: String): Int
56+
def compose[A](g: A => Int): A => Char
57+
def concat(x$1: String): String
58+
def contains(x$1: CharSequence): Boolean
59+
def containsSlice[B](that: scala.collection.GenSeq[B]): Boolean
60+
def contains[A1 >: Char](elem: A1): Boolean
61+
def contentEquals(x$1: CharSequence): Boolean
62+
def contentEquals(x$1: StringBuffer): Boolean
63+
def copyToArray[B >: Char](xs: Array[B]): Unit
64+
def copyToArray[B >: Char](xs: Array[B],start: Int): Unit
65+
def copyToBuffer[B >: Char](dest: scala.collection.mutable.Buffer[B]): Unit
66+
def corresponds[B](that: scala.collection.GenSeq[B])(p: (Char, B) => Boolean): Boolean
67+
def count(p: Char => Boolean): Int
68+
def diff[B >: Char](that: scala.collection.GenSeq[B]): String
69+
def distinct: String
70+
def endsWith(x$1: String): Boolean
71+
def ensuring(cond: Boolean): String
72+
def ensuring(cond: Boolean,msg: => Any): String
73+
def ensuring(cond: String => Boolean): String
74+
def ensuring(cond: String => Boolean,msg: => Any): String
75+
def equals(x$1: Any): Boolean
76+
def equalsIgnoreCase(x$1: String): Boolean
77+
def filter(p: Char => Boolean): String
78+
def filterNot(p: Char => Boolean): String
79+
def flatMap[B, That](f: Char => scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
80+
def flatMap[B, That](f: Char => scala.collection.GenTraversableOnce[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
81+
def flatten[B](implicit asTraversable: Char => scala.collection.GenTraversableOnce[B]): scala.collection.immutable.IndexedSeq[B]
82+
def fold[A1 >: Char](z: A1)(op: (A1, A1) => A1): A1
83+
def format(args: Any*): String
84+
def formatLocal(l: java.util.Locale,args: Any*): String
85+
def formatted(fmtstr: String): String
86+
def genericBuilder[B]: scala.collection.mutable.Builder[B,scala.collection.immutable.IndexedSeq[B]]
87+
def getBytes(): Array[Byte]
88+
def getBytes(x$1: Int,x$2: Int,x$3: Array[Byte],x$4: Int): Unit
89+
def getBytes(x$1: String): Array[Byte]
90+
def getBytes(x$1: java.nio.charset.Charset): Array[Byte]
91+
def getChars(x$1: Int,x$2: Int,x$3: Array[Char],x$4: Int): Unit
92+
def groupBy[K](f: Char => K): scala.collection.immutable.Map[K,String]
93+
def grouped(size: Int): Iterator[String]
94+
def hasDefiniteSize: Boolean
95+
def hashCode(): Int
96+
def headOption: Option[Char]
97+
def indexOf(x$1: Int): Int
98+
def indexOf(x$1: Int,x$2: Int): Int
99+
def indexOf(x$1: String): Int
100+
def indexOf(x$1: String,x$2: Int): Int
101+
def indexOfSlice[B >: Char](that: scala.collection.GenSeq[B]): Int
102+
def indexOfSlice[B >: Char](that: scala.collection.GenSeq[B],from: Int): Int
103+
def indexOf[B >: Char](elem: B): Int
104+
def indexOf[B >: Char](elem: B,from: Int): Int
105+
def indexWhere(p: Char => Boolean): Int
106+
def indices: scala.collection.immutable.Range
107+
def inits: Iterator[String]
108+
def intern(): String
109+
def intersect[B >: Char](that: scala.collection.GenSeq[B]): String
110+
def isDefinedAt(idx: Int): Boolean
111+
def isEmpty(): Boolean
112+
def lastIndexOf(x$1: Int): Int
113+
def lastIndexOf(x$1: Int,x$2: Int): Int
114+
def lastIndexOf(x$1: String): Int
115+
def lastIndexOf(x$1: String,x$2: Int): Int
116+
def lastIndexOfSlice[B >: Char](that: scala.collection.GenSeq[B]): Int
117+
def lastIndexOfSlice[B >: Char](that: scala.collection.GenSeq[B],end: Int): Int
118+
def lastIndexOf[B >: Char](elem: B): Int
119+
def lastIndexOf[B >: Char](elem: B,end: Int): Int
120+
def lastIndexWhere(p: Char => Boolean): Int
121+
def lastOption: Option[Char]
122+
def length(): Int
123+
def lift: Int => Option[Char]
124+
def lines: Iterator[String]
125+
def linesIterator: Iterator[String]
126+
def linesWithSeparators: Iterator[String]
127+
def map[B, That](f: Char => B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
128+
def map[B, That](f: Char => B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
129+
def matches(x$1: String): Boolean
130+
def maxBy[B](f: Char => B)(implicit cmp: Ordering[B]): Char
131+
def max[B >: Char](implicit cmp: Ordering[B]): Char
132+
def minBy[B](f: Char => B)(implicit cmp: Ordering[B]): Char
133+
def min[B >: Char](implicit cmp: Ordering[B]): Char
134+
def mkString(sep: String): String
135+
def mkString(start: String,sep: String,end: String): String
136+
def nonEmpty: Boolean
137+
def offsetByCodePoints(x$1: Int,x$2: Int): Int
138+
def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1,B1]): PartialFunction[A1,B1]
139+
def padTo[B >: Char, That](len: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
140+
def padTo[B >: Char, That](len: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
141+
def par: scala.collection.parallel.ParSeq[Char]
142+
def partition(p: Char => Boolean): (String, String)
143+
def patch[B >: Char, That](from: Int,patch: scala.collection.GenSeq[B],replaced: Int)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
144+
def patch[B >: Char, That](from: Int,patch: scala.collection.GenSeq[B],replaced: Int)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
145+
def permutations: Iterator[String]
146+
def prefixLength(p: Char => Boolean): Int
147+
def product[B >: Char](implicit num: Numeric[B]): B
148+
def r(groupNames: String*): scala.util.matching.Regex
149+
def r: scala.util.matching.Regex
150+
def reduceLeftOption[B >: Char](op: (B, Char) => B): Option[B]
151+
def reduceOption[A1 >: Char](op: (A1, A1) => A1): Option[A1]
152+
def reduceRightOption[B >: Char](op: (Char, B) => B): Option[B]
153+
def reduce[A1 >: Char](op: (A1, A1) => A1): A1
154+
def regionMatches(x$1: Boolean,x$2: Int,x$3: String,x$4: Int,x$5: Int): Boolean
155+
def regionMatches(x$1: Int,x$2: String,x$3: Int,x$4: Int): Boolean
156+
def replace(x$1: Char,x$2: Char): String
157+
def replace(x$1: CharSequence,x$2: CharSequence): String
158+
def replaceAll(x$1: String,x$2: String): String
159+
def replaceAllLiterally(literal: String,replacement: String): String
160+
def replaceFirst(x$1: String,x$2: String): String
161+
def repr: scala.collection.immutable.WrappedString
162+
def reverseMap[B, That](f: Char => B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
163+
def reverseMap[B, That](f: Char => B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
164+
def runWith[U](action: Char => U): Int => Boolean
165+
def scanLeft[B, That](z: B)(op: (B, Char) => B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
166+
def scanLeft[B, That](z: B)(op: (B, Char) => B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
167+
def scanRight[B, That](z: B)(op: (Char, B) => B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
168+
def scanRight[B, That](z: B)(op: (Char, B) => B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
169+
def scan[B >: Char, That](z: B)(op: (B, B) => B)(implicit cbf: scala.collection.generic.CanBuildFrom[String,B,That]): That
170+
def scan[B >: Char, That](z: B)(op: (B, B) => B)(implicit cbf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
171+
def seq: scala.collection.immutable.WrappedString
172+
def sliding(size: Int): Iterator[String]
173+
def sliding(size: Int,step: Int): Iterator[String]
174+
def sortBy[B](f: Char => B)(implicit ord: scala.math.Ordering[B]): String
175+
def sortWith(lt: (Char, Char) => Boolean): String
176+
def sorted[B >: Char](implicit ord: scala.math.Ordering[B]): String
177+
def split(separator: Char): Array[String]
178+
def split(separators: Array[Char]): Array[String]
179+
def split(x$1: String): Array[String]
180+
def split(x$1: String,x$2: Int): Array[String]
181+
def startsWith(x$1: String): Boolean
182+
def startsWith(x$1: String,x$2: Int): Boolean
183+
def startsWith[B](that: scala.collection.GenSeq[B]): Boolean
184+
def stringPrefix: String
185+
def stripLineEnd: String
186+
def stripMargin(marginChar: Char): String
187+
def stripMargin: String
188+
def stripPrefix(prefix: String): String
189+
def stripSuffix(suffix: String): String
190+
def subSequence(x$1: Int,x$2: Int): CharSequence
191+
def substring(x$1: Int): String
192+
def substring(x$1: Int,x$2: Int): String
193+
def sum[B >: Char](implicit num: Numeric[B]): B
194+
def tails: Iterator[String]
195+
def toBoolean: Boolean
196+
def toByte: Byte
197+
def toCharArray(): Array[Char]
198+
def toDouble: Double
199+
def toFloat: Float
200+
def toIndexedSeq: scala.collection.immutable.IndexedSeq[Char]
201+
def toInt: Int
202+
def toList: List[Char]
203+
def toLong: Long
204+
def toLowerCase(): String
205+
def toLowerCase(x$1: java.util.Locale): String
206+
def toMap[T, U](implicit ev: <:<[Char,(T, U)]): scala.collection.immutable.Map[T,U]
207+
def toSet[B >: Char]: scala.collection.immutable.Set[B]
208+
def toShort: Short
209+
def toString(): String
210+
def toTraversable: Traversable[Char]
211+
def toUpperCase(): String
212+
def toUpperCase(x$1: java.util.Locale): String
213+
def toVector: Vector[Char]
214+
def transpose[B](implicit asTraversable: Char => scala.collection.GenTraversableOnce[B]): scala.collection.immutable.IndexedSeq[scala.collection.immutable.IndexedSeq[B]]
215+
def trim(): String
216+
def unzip3[A1, A2, A3](implicit asTriple: Char => (A1, A2, A3)): (scala.collection.immutable.IndexedSeq[A1], scala.collection.immutable.IndexedSeq[A2], scala.collection.immutable.IndexedSeq[A3])
217+
def unzip[A1, A2](implicit asPair: Char => (A1, A2)): (scala.collection.immutable.IndexedSeq[A1], scala.collection.immutable.IndexedSeq[A2])
218+
def updated[B >: Char, That](index: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
219+
def updated[B >: Char, That](index: Int,elem: B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
220+
def withFilter(p: Char => Boolean): scala.collection.generic.FilterMonadic[Char,String]
221+
def zipAll[B, A1 >: Char, That](that: scala.collection.GenIterable[B],thisElem: A1,thatElem: B)(implicit bf: scala.collection.generic.CanBuildFrom[String,(A1, B),That]): That
222+
def zipAll[B, A1 >: Char, That](that: scala.collection.GenIterable[B],thisElem: A1,thatElem: B)(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,(A1, B),That]): That
223+
def →[B](y: B): (String, B)
224+
final def !=(x$1: Any): Boolean
225+
final def ##(): Int
226+
final def +(x$1: Any): String
227+
final def ==(x$1: Any): Boolean
228+
final def asInstanceOf[T0]: T0
229+
final def eq(x$1: AnyRef): Boolean
230+
final def isInstanceOf[T0]: Boolean
231+
final def isTraversableAgain: Boolean
232+
final def ne(x$1: AnyRef): Boolean
233+
final def notify(): Unit
234+
final def notifyAll(): Unit
235+
final def synchronized[T0](x$1: T0): T0
236+
final def wait(): Unit
237+
final def wait(x$1: Long): Unit
238+
final def wait(x$1: Long,x$2: Int): Unit
239+
override def andThen[C](k: Char => C): PartialFunction[Int,C]
240+
override def apply(index: Int): Char
241+
override def canEqual(that: Any): Boolean
242+
override def companion: scala.collection.generic.GenericCompanion[scala.collection.immutable.IndexedSeq]
243+
override def compare(other: String): Int
244+
override def copyToArray[B >: Char](xs: Array[B],start: Int,len: Int): Unit
245+
override def drop(n: Int): String
246+
override def dropRight(n: Int): String
247+
override def dropWhile(p: Char => Boolean): String
248+
override def endsWith[B](that: scala.collection.GenSeq[B]): Boolean
249+
override def exists(p: Char => Boolean): Boolean
250+
override def find(p: Char => Boolean): Option[Char]
251+
override def foldLeft[B](z: B)(op: (B, Char) => B): B
252+
override def foldRight[B](z: B)(op: (Char, B) => B): B
253+
override def forall(p: Char => Boolean): Boolean
254+
override def foreach[U](f: Char => U): Unit
255+
override def head: Char
256+
override def indexWhere(p: Char => Boolean,from: Int): Int
257+
override def init: String
258+
override def iterator: Iterator[Char]
259+
override def last: Char
260+
override def lastIndexWhere(p: Char => Boolean,end: Int): Int
261+
override def lengthCompare(len: Int): Int
262+
override def mkString: String
263+
override def reduceLeft[B >: Char](op: (B, Char) => B): B
264+
override def reduceRight[B >: Char](op: (Char, B) => B): B
265+
override def reverse: String
266+
override def reverseIterator: Iterator[Char]
267+
override def sameElements[B >: Char](that: scala.collection.GenIterable[B]): Boolean
268+
override def segmentLength(p: Char => Boolean,from: Int): Int
269+
override def size: Int
270+
override def slice(from: Int,until: Int): String
271+
override def span(p: Char => Boolean): (String, String)
272+
override def splitAt(n: Int): (String, String)
273+
override def startsWith[B](that: scala.collection.GenSeq[B],offset: Int): Boolean
274+
override def tail: String
275+
override def take(n: Int): String
276+
override def takeRight(n: Int): String
277+
override def takeWhile(p: Char => Boolean): String
278+
override def toArray[B >: Char](implicit evidence$1: scala.reflect.ClassTag[B]): Array[B]
279+
override def toBuffer[A1 >: Char]: scala.collection.mutable.Buffer[A1]
280+
override def toIterable: Iterable[Char]
281+
override def toIterator: Iterator[Char]
282+
override def toSeq: Seq[Char]
283+
override def toStream: scala.collection.immutable.Stream[Char]
284+
override def to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,Char,Col[Char]]): Col[Char]
285+
override def union[B >: Char, That](that: scala.collection.GenSeq[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,B,That]): That
286+
override def union[B >: Char, That](that: scala.collection.GenSeq[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,B,That]): That
287+
override def view(from: Int,until: Int): scala.collection.SeqView[Char,String]
288+
override def view: scala.collection.SeqView[Char,String]
289+
override def zipWithIndex[A1 >: Char, That](implicit bf: scala.collection.generic.CanBuildFrom[String,(A1, Int),That]): That
290+
override def zipWithIndex[A1 >: Char, That](implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,(A1, Int),That]): That
291+
override def zip[A1 >: Char, B, That](that: scala.collection.GenIterable[B])(implicit bf: scala.collection.generic.CanBuildFrom[String,(A1, B),That]): That
292+
override def zip[A1 >: Char, B, That](that: scala.collection.GenIterable[B])(implicit bf: scala.collection.generic.CanBuildFrom[scala.collection.immutable.WrappedString,(A1, B),That]): That
293+
private[this] val repr: String
294+
private[this] val self: String
8295
================================================================================

0 commit comments

Comments
 (0)