From 9e1bf7743355de040a23fbcfe9b1efb9b1db1789 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Fri, 22 Nov 2013 18:12:42 +0100 Subject: Renaming: typeConstructor -> typeRef --- src/dotty/tools/dotc/core/Definitions.scala | 72 ++++++++++++++--------------- 1 file changed, 36 insertions(+), 36 deletions(-) (limited to 'src/dotty/tools/dotc/core/Definitions.scala') diff --git a/src/dotty/tools/dotc/core/Definitions.scala b/src/dotty/tools/dotc/core/Definitions.scala index 9d03d001f..f7f3bde87 100644 --- a/src/dotty/tools/dotc/core/Definitions.scala +++ b/src/dotty/tools/dotc/core/Definitions.scala @@ -144,9 +144,9 @@ class Definitions(implicit ctx: Context) { lazy val NotNullClass = requiredClass("scala.NotNull") lazy val NothingClass: ClassSymbol = newCompleteClassSymbol( - ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeConstructor)) + ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef)) lazy val NullClass: ClassSymbol = newCompleteClassSymbol( - ScalaPackageClass, tpnme.Null, AbstractFinal, List(AnyRefAlias.typeConstructor)) + ScalaPackageClass, tpnme.Null, AbstractFinal, List(AnyRefAlias.typeRef)) lazy val PredefModule = requiredModule("scala.Predef") lazy val NilModule = requiredModule("scala.collection.immutable.Nil") @@ -157,7 +157,7 @@ class Definitions(implicit ctx: Context) { // but does not define it as an explicit class. newCompleteClassSymbol( ScalaPackageClass, tpnme.Singleton, Trait | Interface | Final, - List(AnyClass.typeConstructor), EmptyScope) + List(AnyClass.typeRef), EmptyScope) lazy val SeqClass: ClassSymbol = requiredClass("scala.collection.Seq") lazy val ArrayClass: ClassSymbol = requiredClass("scala.Array") lazy val uncheckedStableClass: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable") @@ -235,35 +235,35 @@ class Definitions(implicit ctx: Context) { def methOfAnyRef(tp: Type) = MethodType(List(AnyRefType), tp) // Derived types - def AnyType: Type = AnyClass.typeConstructor - def AnyValType: Type = AnyValClass.typeConstructor - def ObjectType: Type = ObjectClass.typeConstructor - def AnyRefType: Type = AnyRefAlias.typeConstructor - def NotNullType: Type = NotNullClass.typeConstructor - def NothingType: Type = NothingClass.typeConstructor - def NullType: Type = NullClass.typeConstructor - def SeqType: Type = SeqClass.typeConstructor - def ArrayType: Type = ArrayClass.typeConstructor + def AnyType: Type = AnyClass.typeRef + def AnyValType: Type = AnyValClass.typeRef + def ObjectType: Type = ObjectClass.typeRef + def AnyRefType: Type = AnyRefAlias.typeRef + def NotNullType: Type = NotNullClass.typeRef + def NothingType: Type = NothingClass.typeRef + def NullType: Type = NullClass.typeRef + def SeqType: Type = SeqClass.typeRef + def ArrayType: Type = ArrayClass.typeRef def ObjectArrayType = ArrayType.appliedTo(ObjectType) - def UnitType: Type = UnitClass.typeConstructor - def BooleanType: Type = BooleanClass.typeConstructor - def ByteType: Type = ByteClass.typeConstructor - def ShortType: Type = ShortClass.typeConstructor - def CharType: Type = CharClass.typeConstructor - def IntType: Type = IntClass.typeConstructor - def LongType: Type = LongClass.typeConstructor - def FloatType: Type = FloatClass.typeConstructor - def DoubleType: Type = DoubleClass.typeConstructor - def PairType: Type = PairClass.typeConstructor - def StringType: Type = StringClass.typeConstructor - def RepeatedParamType = RepeatedParamClass.typeConstructor - def JavaRepeatedParamType = JavaRepeatedParamClass.typeConstructor - def ThrowableType = ThrowableClass.typeConstructor - def OptionType = OptionClass.typeConstructor + def UnitType: Type = UnitClass.typeRef + def BooleanType: Type = BooleanClass.typeRef + def ByteType: Type = ByteClass.typeRef + def ShortType: Type = ShortClass.typeRef + def CharType: Type = CharClass.typeRef + def IntType: Type = IntClass.typeRef + def LongType: Type = LongClass.typeRef + def FloatType: Type = FloatClass.typeRef + def DoubleType: Type = DoubleClass.typeRef + def PairType: Type = PairClass.typeRef + def StringType: Type = StringClass.typeRef + def RepeatedParamType = RepeatedParamClass.typeRef + def JavaRepeatedParamType = JavaRepeatedParamClass.typeRef + def ThrowableType = ThrowableClass.typeRef + def OptionType = OptionClass.typeRef def ClassType(arg: Type)(implicit ctx: Context) = { - val ctype = ClassClass.typeConstructor + val ctype = ClassClass.typeRef if (ctx.phase.erasedTypes) ctype else ctype.appliedTo(arg) } @@ -273,11 +273,11 @@ class Definitions(implicit ctx: Context) { // - sym: the symbol of the actual enumeration value (VAL1) // - .owner: the ModuleClassSymbol of the enumeration (object E) // - .linkedClass: the ClassSymbol of the enumeration (class E) - sym.owner.linkedClass.typeConstructor + sym.owner.linkedClass.typeRef object FunctionType { def apply(args: List[Type], resultType: Type) = - FunctionClass(args.length).typeConstructor.appliedTo(args :+ resultType) + FunctionClass(args.length).typeRef.appliedTo(args :+ resultType) def unapply(ft: Type) = { val tsym = ft.typeSymbol lazy val targs = ft.typeArgs @@ -362,7 +362,7 @@ class Definitions(implicit ctx: Context) { val paramDecls = newScope for ((v, i) <- vcs.zipWithIndex) newTypeParam(cls, tpnme.higherKindedParamName(i), varianceFlags(v), paramDecls) - denot.info = ClassInfo(ScalaPackageClass.thisType, cls, List(ObjectClass.typeConstructor), paramDecls) + denot.info = ClassInfo(ScalaPackageClass.thisType, cls, List(ObjectClass.typeRef), paramDecls) } } @@ -657,8 +657,8 @@ class Definitions(implicit ctx: Context) { // convenient one-argument parameter lists lazy val anyparam = List(AnyClass.tpe) - lazy val anyvalparam = List(AnyValClass.typeConstructor) - lazy val anyrefparam = List(AnyRefClass.typeConstructor) + lazy val anyvalparam = List(AnyValClass.typeRef) + lazy val anyrefparam = List(AnyRefClass.typeRef) // private parameter conveniences private def booltype = BooleanClass.tpe @@ -1205,7 +1205,7 @@ class Definitions(implicit ctx: Context) { /** Given type U, creates a Type representing Class[_ <: U]. */ def boundedClassType(upperBound: Type) = - appliedTypeAsUpperBounds(ClassClass.typeConstructor, List(upperBound)) + appliedTypeAsUpperBounds(ClassClass.typeRef, List(upperBound)) /** To avoid unchecked warnings on polymorphic classes, translate * a Foo[T] into a Foo[_] for use in the pattern matcher. @@ -1262,7 +1262,7 @@ class Definitions(implicit ctx: Context) { // java.lang.Object. Java also special cases the return type. lazy val Any_getClass = enterNewMethod(AnyClass, nme.getClass_, Nil, requiredMethod(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED) lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, Final)(_ => BooleanType) - lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, Final)(_.typeConstructor) + lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, Final)(_.typeRef) // A type function from T => Class[U], used to determine the return // type of getClass calls. The returned type is: @@ -1692,7 +1692,7 @@ class Definitions(implicit ctx: Context) { // TODO: set type bounds manually (-> MulticastDelegate), see newTypeParam val newCaller = enterNewMethod(DelegateClass, name, paramTypes, delegateType, Final | STATIC) // val newCaller = newPolyMethod(DelegateClass, name, - // tparam => MethodType(paramTypes, tparam.typeConstructor)) setFlag (Final | STATIC) + // tparam => MethodType(paramTypes, tparam.typeRef)) setFlag (Final | STATIC) Delegate_scalaCallers = Delegate_scalaCallers ::: List(newCaller) nbScalaCallers += 1 newCaller -- cgit v1.2.3