diff options
Diffstat (limited to 'src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala')
| -rw-r--r-- | src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala | 37 |
1 files changed, 23 insertions, 14 deletions
diff --git a/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala index 91ac4ea3e..31247c005 100644 --- a/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala +++ b/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala @@ -197,9 +197,9 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { // ------ Reading types ----------------------------------------------------- /** Read names in an interleaved sequence of (parameter) names and types/bounds */ - def readParamNames[N <: Name](end: Addr): List[N] = + def readParamNames(end: Addr): List[Name] = until(end) { - val name = readName().asInstanceOf[N] + val name = readName() skipTree() name } @@ -244,11 +244,11 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { def readLengthType(): Type = { val end = readEnd() - def readNamesSkipParams[N <: Name]: (List[N], TreeReader) = { + def readNamesSkipParams: (List[Name], TreeReader) = { val nameReader = fork nameReader.skipTree() // skip result val paramReader = nameReader.fork - (nameReader.readParamNames[N](end), paramReader) + (nameReader.readParamNames(end), paramReader) } val result = @@ -260,7 +260,7 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { val parent = readType() val ttag = nextUnsharedTag if (ttag == TYPEBOUNDS || ttag == TYPEALIAS) name = name.toTypeName - RefinedType(parent, name, rt => registeringType(rt, readType())) + RefinedType(parent, name, readType()) // Note that the lambda "rt => ..." is not equivalent to a wildcard closure! // Eta expansion of the latter puts readType() out of the expression. case APPLIEDtype => @@ -284,22 +284,31 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { val sym = ctx.newSymbol(ctx.owner, readName().toTypeName, BindDefinedType, readType()) registerSym(start, sym) TypeRef.withFixedSym(NoPrefix, sym.name, sym) + case LAMBDAtype => + val (rawNames, paramReader) = readNamesSkipParams + val (variances, paramNames) = rawNames + .map(name => (prefixToVariance(name.head), name.tail.toTypeName)).unzip + val result = TypeLambda(paramNames, variances)( + pt => registeringType(pt, paramReader.readParamTypes[TypeBounds](end)), + pt => readType()) + goto(end) + result case POLYtype => - val (names, paramReader) = readNamesSkipParams[TypeName] - val result = PolyType(names)( + val (names, paramReader) = readNamesSkipParams + val result = PolyType(names.map(_.toTypeName))( pt => registeringType(pt, paramReader.readParamTypes[TypeBounds](end)), pt => readType()) goto(end) result case METHODtype => - val (names, paramReader) = readNamesSkipParams[TermName] - val result = MethodType(names, paramReader.readParamTypes[Type](end))( + val (names, paramReader) = readNamesSkipParams + val result = MethodType(names.map(_.toTermName), paramReader.readParamTypes[Type](end))( mt => registeringType(mt, readType())) goto(end) result case PARAMtype => readTypeRef() match { - case binder: PolyType => PolyParam(binder, readNat()) + case binder: GenericType => PolyParam(binder, readNat()) case binder: MethodType => MethodParam(binder, readNat()) } case CLASSconst => @@ -322,8 +331,6 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { readPackageRef().termRef case TYPEREF => val name = readName().toTypeName - if (name.isLambdaTraitName) // Make sure curresponding lambda trait exists - defn.LambdaTrait(name.lambdaTraitVariances) TypeRef(readType(), name) case TERMREF => readNameSplitSig() match { @@ -332,8 +339,10 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table) { } case THIS => ThisType.raw(readType().asInstanceOf[TypeRef]) - case REFINEDthis => - RefinedThis(readTypeRef().asInstanceOf[RefinedType]) + case RECtype => + RecType(rt => registeringType(rt, readType())) + case RECthis => + RecThis(readTypeRef().asInstanceOf[RecType]) case SHARED => val ref = readAddr() typeAtAddr.getOrElseUpdate(ref, forkAt(ref).readType()) |