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 ++-- .../tools/dotc/transform/ElimErasedValueType.scala | 2 +- .../dotty/tools/dotc/transform/ElimRepeated.scala | 8 ++++---- .../dotty/tools/dotc/transform/ExplicitOuter.scala | 2 +- .../tools/dotc/transform/FullParameterization.scala | 2 +- .../tools/dotc/transform/ShortcutImplicits.scala | 4 ++-- .../dotty/tools/dotc/transform/SuperAccessors.scala | 4 ++-- .../src/dotty/tools/dotc/typer/Applications.scala | 2 +- .../src/dotty/tools/dotc/typer/ErrorReporting.scala | 2 +- compiler/src/dotty/tools/dotc/typer/Inliner.scala | 2 +- .../src/dotty/tools/dotc/typer/ProtoTypes.scala | 2 +- .../src/dotty/tools/dotc/typer/TypeAssigner.scala | 2 +- 17 files changed, 34 insertions(+), 45 deletions(-) (limited to 'compiler/src/dotty') 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) = diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala index 25c01c1f7..48be02fa1 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala @@ -46,7 +46,7 @@ class ElimErasedValueType extends MiniPhaseTransform with InfoTransformer { case tp: MethodType => val paramTypes = tp.paramInfos.mapConserve(elimEVT) val retType = elimEVT(tp.resultType) - tp.derivedMethodType(tp.paramNames, paramTypes, retType) + tp.derivedLambdaType(tp.paramNames, paramTypes, retType) case _ => tp } diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala index bc2674a77..683c8ac38 100644 --- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala +++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala @@ -55,9 +55,9 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati val last = paramTypes.last.underlyingIfRepeated(tp.isJava) paramTypes.init :+ last } else paramTypes - tp.derivedMethodType(paramNames, paramTypes1, resultType1) + tp.derivedLambdaType(paramNames, paramTypes1, resultType1) case tp: PolyType => - tp.derivedPolyType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType)) + tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType)) case tp => tp } @@ -139,10 +139,10 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati /** Convert type from Scala to Java varargs method */ private def toJavaVarArgs(tp: Type)(implicit ctx: Context): Type = tp match { case tp: PolyType => - tp.derivedPolyType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType)) + tp.derivedLambdaType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType)) case tp: MethodType => val inits :+ last = tp.paramInfos val last1 = last.underlyingIfRepeated(isJava = true) - tp.derivedMethodType(tp.paramNames, inits :+ last1, tp.resultType) + tp.derivedLambdaType(tp.paramNames, inits :+ last1, tp.resultType) } } diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala index f17808e62..a6e643992 100644 --- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala +++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala @@ -331,7 +331,7 @@ object ExplicitOuter { def addParam(cls: ClassSymbol, tp: Type): Type = if (hasOuterParam(cls)) { val mt @ MethodTpe(pnames, ptypes, restpe) = tp - mt.derivedMethodType( + mt.derivedLambdaType( nme.OUTER :: pnames, cls.owner.enclosingClass.typeRef :: ptypes, restpe) } else tp diff --git a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala index 0b9ec9085..d76a41946 100644 --- a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala +++ b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala @@ -256,7 +256,7 @@ object FullParameterization { case MethodTpe(nme.SELF :: Nil, _, restpe) => restpe.ensureMethodic.signature case info @ MethodTpe(nme.SELF :: otherNames, thisType :: otherTypes, restpe) => - info.derivedMethodType(otherNames, otherTypes, restpe).signature + info.derivedLambdaType(otherNames, otherTypes, restpe).signature case _ => Signature.NotAMethod } diff --git a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala index b5469610f..1a530b95c 100644 --- a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala +++ b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala @@ -82,8 +82,8 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisTr * @return The type of the `apply` member of `implicit Ts => R`. */ private def directInfo(info: Type)(implicit ctx: Context): Type = info match { - case info: PolyType => info.derivedPolyType(resType = directInfo(info.resultType)) - case info: MethodType => info.derivedMethodType(resType = directInfo(info.resultType)) + case info: PolyType => info.derivedLambdaType(resType = directInfo(info.resultType)) + case info: MethodType => info.derivedLambdaType(resType = directInfo(info.resultType)) case info: ExprType => directInfo(info.resultType) case info => info.member(nme.apply).info } diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala index 102b492a8..728c1696b 100644 --- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala +++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala @@ -178,7 +178,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) { val accType = { def accTypeOf(tpe: Type): Type = tpe match { case tpe: PolyType => - tpe.derivedPolyType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType)) + tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType)) case _ => MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0))) } @@ -230,7 +230,7 @@ class SuperAccessors(thisTransformer: DenotTransformer) { else clazz.classInfo.selfType def accTypeOf(tpe: Type): Type = tpe match { case tpe: PolyType => - tpe.derivedPolyType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType)) + tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, accTypeOf(tpe.resultType)) case _ => MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0))) } diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala index ceaf3471a..236bc051e 100644 --- a/compiler/src/dotty/tools/dotc/typer/Applications.scala +++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala @@ -1125,7 +1125,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic => case mt: ImplicitMethodType => resultTypeApprox(mt) case pt: PolyType => - pt.derivedPolyType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType)) + pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType)) case _ => tp } diff --git a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala index 5f9eae3da..5063a111c 100644 --- a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala +++ b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala @@ -105,7 +105,7 @@ object ErrorReporting { def whyNoMatchStr(found: Type, expected: Type) = { def dropJavaMethod(tp: Type): Type = tp match { case tp: PolyType => - tp.derivedPolyType(resType = dropJavaMethod(tp.resultType)) + tp.derivedLambdaType(resType = dropJavaMethod(tp.resultType)) case tp: JavaMethodType => MethodType(tp.paramNames, tp.paramInfos, dropJavaMethod(tp.resultType)) case tp => tp diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala index cf3076fce..6ef6c12cc 100644 --- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala +++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala @@ -108,7 +108,7 @@ object Inliner { // Add qualifier type as leading method argument to argument `tp` def addQualType(tp: Type): Type = tp match { - case tp: PolyType => tp.derivedPolyType(tp.paramNames, tp.paramInfos, addQualType(tp.resultType)) + case tp: PolyType => tp.derivedLambdaType(tp.paramNames, tp.paramInfos, addQualType(tp.resultType)) case tp: ExprType => addQualType(tp.resultType) case tp => MethodType(qualType :: Nil, tp) } diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala index 2dccbbcc1..a27175abd 100644 --- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala +++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala @@ -444,7 +444,7 @@ object ProtoTypes { val rt = normalize(mt.resultType, pt) pt match { case pt: IgnoredProto => mt - case pt: ApplyingProto => mt.derivedMethodType(mt.paramNames, mt.paramInfos, rt) + case pt: ApplyingProto => mt.derivedLambdaType(mt.paramNames, mt.paramInfos, rt) case _ => val ft = defn.FunctionOf(mt.paramInfos, rt) if (mt.paramInfos.nonEmpty || ft <:< pt) ft else rt diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala index ed71f2239..14d4f315d 100644 --- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala +++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala @@ -366,7 +366,7 @@ trait TypeAssigner { if (gapBuf.isEmpty) resultType1 else { val gaps = gapBuf.toList - pt.derivedPolyType( + pt.derivedLambdaType( gaps.map(paramNames), gaps.map(idx => transform(pt.paramInfos(idx)).bounds), resultType1) -- cgit v1.2.3