@@ -291,23 +291,24 @@ object NameOps {
291
291
case nme.clone_ => nme.clone_
292
292
}
293
293
294
- def specializedFor (classTargs : List [Types .Type ], classTargsNames : List [Name ], methodTargs : List [Types .Type ], methodTarsNames : List [Name ])(implicit ctx : Context ): name.ThisName = {
295
-
296
- def typeToTag (tp : Types .Type ): Name = {
297
- tp.classSymbol match {
298
- case t if t eq defn.IntClass => nme.specializedTypeNames.Int
299
- case t if t eq defn.BooleanClass => nme.specializedTypeNames.Boolean
300
- case t if t eq defn.ByteClass => nme.specializedTypeNames.Byte
301
- case t if t eq defn.LongClass => nme.specializedTypeNames.Long
302
- case t if t eq defn.ShortClass => nme.specializedTypeNames.Short
303
- case t if t eq defn.FloatClass => nme.specializedTypeNames.Float
304
- case t if t eq defn.UnitClass => nme.specializedTypeNames.Void
305
- case t if t eq defn.DoubleClass => nme.specializedTypeNames.Double
306
- case t if t eq defn.CharClass => nme.specializedTypeNames.Char
307
- case _ => nme.specializedTypeNames.Object
308
- }
294
+ private def typeToTag (tp : Types .Type )(implicit ctx : Context ): Name =
295
+ tp.classSymbol match {
296
+ case t if t eq defn.IntClass => nme.specializedTypeNames.Int
297
+ case t if t eq defn.BooleanClass => nme.specializedTypeNames.Boolean
298
+ case t if t eq defn.ByteClass => nme.specializedTypeNames.Byte
299
+ case t if t eq defn.LongClass => nme.specializedTypeNames.Long
300
+ case t if t eq defn.ShortClass => nme.specializedTypeNames.Short
301
+ case t if t eq defn.FloatClass => nme.specializedTypeNames.Float
302
+ case t if t eq defn.UnitClass => nme.specializedTypeNames.Void
303
+ case t if t eq defn.DoubleClass => nme.specializedTypeNames.Double
304
+ case t if t eq defn.CharClass => nme.specializedTypeNames.Char
305
+ case _ => nme.specializedTypeNames.Object
309
306
}
310
307
308
+ /** This method is to be used on type parameters from a class, since this
309
+ * method does sorting based on their names
310
+ */
311
+ def specializedFor (classTargs : List [Types .Type ], classTargsNames : List [Name ], methodTargs : List [Types .Type ], methodTarsNames : List [Name ])(implicit ctx : Context ): name.ThisName = {
311
312
val methodTags : Seq [Name ] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => typeToTag(x._1))
312
313
val classTags : Seq [Name ] = (classTargs zip classTargsNames).sortBy(_._2).map(x => typeToTag(x._1))
313
314
@@ -316,6 +317,18 @@ object NameOps {
316
317
classTags.fold(nme.EMPTY )(_ ++ _) ++ nme.specializedTypeNames.suffix)
317
318
}
318
319
320
+ /** Use this method if you are **not** creating specialized name from type
321
+ * parameters. The order of names will be:
322
+ *
323
+ * `<return type><first type><second type><...>`
324
+ */
325
+ def specializedFor (args : List [Types .Type ], ret : Types .Type )(implicit ctx : Context ): name.ThisName =
326
+ name.fromName {
327
+ name ++ nme.specializedTypeNames.prefix ++
328
+ nme.specializedTypeNames.separator ++ typeToTag(ret) ++
329
+ args.map(typeToTag).fold(nme.EMPTY )(_ ++ _) ++ nme.specializedTypeNames.suffix
330
+ }
331
+
319
332
/** If name length exceeds allowable limit, replace part of it by hash */
320
333
def compactified (implicit ctx : Context ): TermName = termName(compactify(name.toString))
321
334
}
0 commit comments