From 700e7ac6658a1d699502c94141091012d18519c4 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 17 Mar 2017 14:58:27 +0100 Subject: replace derived{Method,Poly}Type with derivedLambdaType --- .../src/dotty/tools/dotc/core/Denotations.scala | 8 ++++---- .../dotty/tools/dotc/core/TypeApplications.scala | 2 +- .../src/dotty/tools/dotc/core/TypeErasure.scala | 6 +++--- compiler/src/dotty/tools/dotc/core/Types.scala | 21 +++++---------------- .../tools/dotc/core/classfile/ClassfileParser.scala | 6 +++--- .../dotc/core/unpickleScala2/Scala2Unpickler.scala | 4 ++-- 6 files changed, 18 insertions(+), 29 deletions(-) (limited to 'compiler/src/dotty/tools/dotc/core') diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala index 1d7b3c94c..7e552eda9 100644 --- a/compiler/src/dotty/tools/dotc/core/Denotations.scala +++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala @@ -312,7 +312,7 @@ object Denotations { tp2 match { case tp2: MethodType if ctx.typeComparer.matchingParams(tp1.paramInfos, tp2.paramInfos, tp1.isJava, tp2.isJava) && tp1.isImplicit == tp2.isImplicit => - tp1.derivedMethodType( + tp1.derivedLambdaType( mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName), tp1.paramInfos, infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1))) @@ -322,7 +322,7 @@ object Denotations { case tp1: PolyType if isTerm => tp2 match { case tp2: PolyType if ctx.typeComparer.matchingTypeParams(tp1, tp2) => - tp1.derivedPolyType( + tp1.derivedLambdaType( mergeNames(tp1.paramNames, tp2.paramNames, tpnme.syntheticTypeParamName), tp1.paramInfos, infoMeet(tp1.resultType, tp2.resultType.subst(tp2, tp1))) @@ -476,7 +476,7 @@ object Denotations { case tp2: MethodType if ctx.typeComparer.matchingParams(tp1.paramInfos, tp2.paramInfos, tp1.isJava, tp2.isJava) && tp1.isImplicit == tp2.isImplicit => - tp1.derivedMethodType( + tp1.derivedLambdaType( mergeNames(tp1.paramNames, tp2.paramNames, nme.syntheticParamName), tp1.paramInfos, tp1.resultType | tp2.resultType.subst(tp2, tp1)) case _ => @@ -485,7 +485,7 @@ object Denotations { case tp1: PolyType => tp2 match { case tp2: PolyType if ctx.typeComparer.matchingTypeParams(tp1, tp2) => - tp1.derivedPolyType( + tp1.derivedLambdaType( mergeNames(tp1.paramNames, tp2.paramNames, tpnme.syntheticTypeParamName), tp1.paramInfos, tp1.resultType | tp2.resultType.subst(tp2, tp1)) case _ => diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala index 77767a38c..3a63c16db 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala @@ -429,7 +429,7 @@ class TypeApplications(val self: Type) extends AnyVal { // In this case we should always dealias since we cannot handle // higher-kinded applications to wildcard arguments. dealiased - .derivedPolyType(resType = tycon.safeDealias.appliedTo(args1)) + .derivedLambdaType(resType = tycon.safeDealias.appliedTo(args1)) .appliedTo(args) case _ => val reducer = new Reducer(dealiased, args) diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala index 07d613c57..8ff0be9d7 100644 --- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala +++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala @@ -176,7 +176,7 @@ object TypeErasure { val erase = erasureFn(isJava, semiEraseVCs, sym.isConstructor, wildcardOK = false) def eraseParamBounds(tp: PolyType): Type = - tp.derivedPolyType( + tp.derivedLambdaType( tp.paramNames, tp.paramNames map (Function.const(TypeBounds.upper(defn.ObjectType))), tp.resultType) if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType]) @@ -385,9 +385,9 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean val formals = tp.paramInfos.mapConserve(paramErasure) eraseResult(tp.resultType) match { case rt: MethodType => - tp.derivedMethodType(tp.paramNames ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType) + tp.derivedLambdaType(tp.paramNames ++ rt.paramNames, formals ++ rt.paramInfos, rt.resultType) case rt => - tp.derivedMethodType(tp.paramNames, formals, rt) + tp.derivedLambdaType(tp.paramNames, formals, rt) } case tp @ ClassInfo(pre, cls, classParents, decls, _) => if (cls is Package) tp diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala index 49fc825ca..074d2e1fb 100644 --- a/compiler/src/dotty/tools/dotc/core/Types.scala +++ b/compiler/src/dotty/tools/dotc/core/Types.scala @@ -2524,11 +2524,6 @@ object Types { override def computeSignature(implicit ctx: Context): Signature = resultSignature.prepend(paramInfos, isJava) - def derivedMethodType(paramNames: List[TermName] = this.paramNames, - paramInfos: List[Type] = this.paramInfos, - resType: Type = this.resType)(implicit ctx: Context) = - derivedLambdaType(paramNames, paramInfos, resType) - protected def prefixString = "MethodType" } @@ -2697,11 +2692,6 @@ object Types { override def underlying(implicit ctx: Context) = resType - def derivedPolyType(paramNames: List[TypeName] = this.paramNames, - paramInfos: List[TypeBounds] = this.paramInfos, - resType: Type = this.resType)(implicit ctx: Context) = - derivedLambdaType(paramNames, paramInfos, resType) - /** Merge nested polytypes into one polytype. nested polytypes are normally not supported * but can arise as temporary data structures. */ @@ -3467,12 +3457,11 @@ object Types { tp.derivedClassInfo(pre) protected def derivedJavaArrayType(tp: JavaArrayType, elemtp: Type): Type = tp.derivedJavaArrayType(elemtp) - protected def derivedMethodType(tp: MethodType, formals: List[Type], restpe: Type): Type = - tp.derivedMethodType(tp.paramNames, formals, restpe) protected def derivedExprType(tp: ExprType, restpe: Type): Type = tp.derivedExprType(restpe) - protected def derivedPolyType(tp: PolyType, pbounds: List[TypeBounds], restpe: Type): Type = - tp.derivedPolyType(tp.paramNames, pbounds, restpe) + // note: currying needed because Scala2 does not support param-dependencies + protected def derivedLambdaType(tp: LambdaType)(formals: List[tp.PInfo], restpe: Type): Type = + tp.derivedLambdaType(tp.paramNames, formals, restpe) /** Map this function over given type */ def mapOver(tp: Type): Type = { @@ -3507,7 +3496,7 @@ object Types { variance = -variance val ptypes1 = tp.paramInfos mapConserve this variance = -variance - derivedMethodType(tp, ptypes1, this(tp.resultType)) + derivedLambdaType(tp)(ptypes1, this(tp.resultType)) } mapOverMethod @@ -3519,7 +3508,7 @@ object Types { variance = -variance val bounds1 = tp.paramInfos.mapConserve(this).asInstanceOf[List[TypeBounds]] variance = -variance - derivedPolyType(tp, bounds1, this(tp.resultType)) + derivedLambdaType(tp)(bounds1, this(tp.resultType)) } mapOverPoly diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala index 2bb929bf3..da875c906 100644 --- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala +++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala @@ -199,7 +199,7 @@ class ClassfileParser( def stripOuterParamFromConstructor() = innerClasses.get(currentClassName) match { case Some(entry) if !isStatic(entry.jflags) => val mt @ MethodTpe(paramNames, paramTypes, resultType) = denot.info - denot.info = mt.derivedMethodType(paramNames.tail, paramTypes.tail, resultType) + denot.info = mt.derivedLambdaType(paramNames.tail, paramTypes.tail, resultType) case _ => } @@ -209,7 +209,7 @@ class ClassfileParser( def normalizeConstructorInfo() = { val mt @ MethodType(paramNames) = denot.info val rt = classRoot.typeRef appliedTo (classRoot.typeParams map (_.typeRef)) - denot.info = mt.derivedMethodType(paramNames, mt.paramInfos, rt) + denot.info = mt.derivedLambdaType(paramNames, mt.paramInfos, rt) addConstructorTypeParams(denot) } @@ -975,7 +975,7 @@ class ClassfileParser( if (name == nme.CONSTRUCTOR) tpe match { case tp: MethodType => - tp.derivedMethodType(tp.paramNames, tp.paramInfos, ownerTpe) + tp.derivedLambdaType(tp.paramNames, tp.paramInfos, ownerTpe) } p = (name, tpe) values(index) = p diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala index fad516da7..d34bc240f 100644 --- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala +++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala @@ -65,12 +65,12 @@ object Scala2Unpickler { case _ => elemtp0 } - tp.derivedMethodType( + tp.derivedLambdaType( tp.paramNames, tp.paramInfos.init :+ defn.RepeatedParamType.appliedTo(elemtp), tp.resultType) case tp: PolyType => - tp.derivedPolyType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType)) + tp.derivedLambdaType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType)) } def ensureConstructor(cls: ClassSymbol, scope: Scope)(implicit ctx: Context) = -- cgit v1.2.3