From 0aac7396c3eda56375c15568b81f48262d47d35b Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 28 Jan 2013 15:55:33 +0100 Subject: Consolidation of Symbols --- src/dotty/tools/dotc/core/Denotations.scala | 2 +- src/dotty/tools/dotc/core/Flags.scala | 2 + src/dotty/tools/dotc/core/SymDenotations.scala | 95 +++++++++++++---- src/dotty/tools/dotc/core/Symbols.scala | 140 ++++++++++++++++--------- src/dotty/tools/dotc/core/TypeComparers.scala | 2 +- src/dotty/tools/dotc/core/TypeOps.scala | 4 +- src/dotty/tools/dotc/core/Types.scala | 44 ++++---- 7 files changed, 194 insertions(+), 95 deletions(-) (limited to 'src/dotty/tools/dotc') diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala index 12b522427..461ef2f17 100644 --- a/src/dotty/tools/dotc/core/Denotations.scala +++ b/src/dotty/tools/dotc/core/Denotations.scala @@ -175,7 +175,7 @@ object Denotations { else if (denot1.signature == denot2.signature) { def isEligible(sym1: Symbol, sym2: Symbol) = if (sym1.isType) !sym1.isClass - else sym1.isConcrete || sym2.isDeferred || !sym2.exists + else !(sym1 is Deferred) || (sym2 is Deferred) || !sym2.exists def normalize(info: Type) = if (isType) info.bounds else info val sym1 = denot1.symbol diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala index 0e995f756..5f400a3c8 100644 --- a/src/dotty/tools/dotc/core/Flags.scala +++ b/src/dotty/tools/dotc/core/Flags.scala @@ -167,6 +167,8 @@ object Flags { /** A declared, but not defined member */ final val Deferred = commonFlag(5, "") + final val DeferredTerm = Deferred.toTermFlags + final val DeferredType = Deferred.toTypeFlags /** Labeled with `final` modifier */ final val Final = commonFlag(6, "final") diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala index fd8f686b4..7600ff0e4 100644 --- a/src/dotty/tools/dotc/core/SymDenotations.scala +++ b/src/dotty/tools/dotc/core/SymDenotations.scala @@ -103,14 +103,14 @@ object SymDenotations { (o eq sym) } - def withType(tp: Type): SymDenotation = ??? +// def withType(tp: Type): SymDenotation = ??? override protected def copy(s: Symbol, i: Type): SingleDenotation = new UniqueRefDenotation(s, i, validFor) def moduleClass(implicit ctx: Context): Symbol = if (this.isModuleObj) info.typeSymbol else NoSymbol - /** Desire to re-use the field in ClassSymbol which stores the source + /** Desire to re-use the field in ClassSymbol which stores the source * file to also store the classfile, but without changing the behavior * of sourceFile (which is expected at least in the IDE only to * return actual source code.) So sourceFile has classfiles filtered out. @@ -140,6 +140,11 @@ object SymDenotations { info.isVolatile && !hasAnnotation(defn.uncheckedStableClass) ) + def isStatic(implicit ctx: Context) = (this is Static) || owner.isStaticOwner + + final def isStaticOwner(implicit ctx: Context): Boolean = + (this is PackageClass) || (this is ModuleClass) && isStatic + final def matchingSymbol(inClass: Symbol, site: Type)(implicit ctx: Context): Symbol = { var denot = inClass.info.nonPrivateDecl(name) if (denot.isTerm) { @@ -159,8 +164,7 @@ object SymDenotations { final def allOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] = info.baseClasses.tail.iterator map overriddenSymbol filter (_.exists) - /** Is this symbol defined in the same scope and compilation unit as `that` symbol? */ - private def isCoDefinedWith(that: Symbol)(implicit ctx: Context) = + def isCoDefinedWith(that: Symbol)(implicit ctx: Context) = (this.owner == that.owner) && ( !(this.owner.isPackageClass) || (this.sourceFile == null) @@ -169,11 +173,16 @@ object SymDenotations { || (this.sourceFile.canonicalPath == that.sourceFile.canonicalPath) ) - def companionModule(implicit ctx: Context): Symbol = - owner.info.decl(name.toTermName).filter(_.isModule).symbol + def companionModule(implicit ctx: Context): Symbol = { + owner.info.decl(name.toTermName) + .filter(sym => sym.isModule && sym.isCoDefinedWith(symbol)) + .symbol + } def companionClass(implicit ctx: Context): Symbol = - owner.info.decl(name.toTypeName).filter(_.isClass).symbol + owner.info.decl(name.toTypeName) + .filter(sym => sym.isClass && sym.isCoDefinedWith(symbol)) + .symbol def linkedClass(implicit ctx: Context): Symbol = if (this.isModuleClass) companionClass @@ -239,7 +248,7 @@ object SymDenotations { cls.isModuleClass && pre.widen.typeSymbol.isSubClassOrCompanion(cls.linkedClass))) fail(() => - s"""Access to protected $show not permitted because + s"""Access to protected ${symbol.show} not permitted because |prefix type ${pre.widen.show} does not conform to |${cls.showLocated} where the access takes place""".stripMargin) else true @@ -249,7 +258,7 @@ object SymDenotations { val boundary = accessBoundary(owner) ( (boundary.isTerm - || (boundary eq defn.RootClass)) + || (boundary.isRoot)) || (accessWithin(boundary) || accessWithinLinked(boundary)) && ( !(this is Local) || (owner is ImplClass) // allow private local accesses to impl class members @@ -268,8 +277,27 @@ object SymDenotations { def isNonValueClass(implicit ctx: Context): Boolean = isClass && !isSubClass(defn.AnyValClass) - def show(implicit ctx: Context): String = ??? - def showLocated(implicit ctx: Context): String = ??? + def typeParams: List[TypeSymbol] = unsupported("typeParams") + + def thisType(implicit ctx: Context): Type = unsupported("thisType") + + def typeConstructor(implicit ctx: Context): Type = + TypeRef(owner.thisType, name.asTypeName) + + def variance: Int = + if (this is Covariant) 1 + else if (this is Contravariant) -1 + else 0 + + def isRoot: Boolean = !owner.exists // !!! && name == tpnme.Root + + def copy( + sym: Symbol, + owner: Symbol = this.owner, + name: Name = this.name, + initFlags: FlagSet = this.flags, + info: Type = this.info) = + new CompleteSymDenotation(sym, owner, name, initFlags, info) } trait isComplete extends SymDenotation { @@ -334,6 +362,8 @@ object SymDenotations { def parents: List[TypeRef] + def selfType: Type + def decls: Scope val info = ClassInfo(owner.thisType, this) @@ -342,7 +372,7 @@ object SymDenotations { private[this] var _typeParams: List[TypeSymbol] = _ - final def typeParams: List[TypeSymbol] = { + override final def typeParams: List[TypeSymbol] = { val tparams = _typeParams if (tparams != null) tparams else computeTypeParams } @@ -359,20 +389,25 @@ object SymDenotations { memberCacheVar } - private[this] var thisTypeCache: ThisType = null + private[this] var _thisType: Type = null - def thisType(implicit ctx: Context): Type = { - if (thisTypeCache == null) - thisTypeCache = ThisType(symbol) - thisTypeCache + override def thisType(implicit ctx: Context): Type = { + if (_thisType == null) _thisType = computeThisType + _thisType } - private[this] var typeConstructorCache: Type = null + // todo: apply same scheme to static objects/all objects? + private def computeThisType: Type = + if ((this is PackageClass) && !isRoot) + TermRef(owner.thisType, name.toTermName) + else + ThisType(symbol) - def typeConstructor(implicit ctx: Context): Type = { - if (typeConstructorCache == null) - typeConstructorCache = NamedType(thisType, symbol.name) - typeConstructorCache + private[this] var _typeConstructor: Type = null + + override def typeConstructor(implicit ctx: Context): Type = { + if (_typeConstructor == null) _typeConstructor = super.typeConstructor + _typeConstructor } /* @@ -538,7 +573,7 @@ object SymDenotations { else reduce(NoType, classd.parents).substThis(classd.symbol, tp.prefix) } - if (symbol.isStaticMono) symbol.typeConstructor + if (symbol.isStatic) symbol.typeConstructor else tp match { case tp: CachedType => if (baseTypeValid != ctx.runId) { @@ -573,6 +608,17 @@ object SymDenotations { memberNamesCache += (keepOnly -> names) names } + + def copyClass( + sym: ClassSymbol, + owner: Symbol = this.owner, + name: Name = this.name, + initFlags: FlagSet = this.flags, + parents: List[TypeRef] = this.parents, + selfType: Type = this.selfType, + decls: Scope = this.decls, + assocFile: AbstractFile = this.assocFile) = + new CompleteClassDenotation(sym, owner, name, initFlags, parents, selfType, decls, assocFile) } class CompleteClassDenotation( @@ -581,6 +627,7 @@ object SymDenotations { val name: Name, initFlags: FlagSet, val parents: List[TypeRef], + val selfType: Type, val decls: Scope, assocFile: AbstractFile = null )(implicit ctx: Context) extends ClassDenotation(initFlags, assocFile) with isComplete { @@ -596,9 +643,11 @@ object SymDenotations { )(implicit ctx: Context) extends ClassDenotation(initFlags, assocFile) with isLazy { protected var _parents: List[TypeRef] = null + protected var _selfType: Type = null protected var _decls: Scope = null final def parents: List[TypeRef] = { ensureCompleted(); _parents } + final def selfType: Type = { ensureCompleted(); _selfType } final def decls: Scope = { ensureCompleted(); _decls } final def preCompleteDecls = {ensureLoaded(); _decls } } diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala index 84ffc53a7..fc971b686 100644 --- a/src/dotty/tools/dotc/core/Symbols.scala +++ b/src/dotty/tools/dotc/core/Symbols.scala @@ -20,7 +20,9 @@ object Symbols { /** A Symbol represents a Scala definition/declaration or a package. */ - abstract class Symbol(denotf: Symbol => SymDenotation) { + abstract class Symbol(denotf: Symbol => SymDenotation) extends DotClass { + + type Name <: Names.Name /** Is symbol different from NoSymbol? */ def exists = true @@ -33,16 +35,30 @@ object Symbols { /** The last denotation of this symbol */ private[this] var lastDenot: SymDenotation = denotf(this) + /** The current denotation of this symbol */ final def denot(implicit ctx: Context): SymDenotation = { var denot = lastDenot if (!(denot.validFor contains ctx.period)) denot = denot.current.asInstanceOf[SymDenotation] denot } + /** Subclass tests and casts */ def isType: Boolean = false def isTerm: Boolean = false def isClass: Boolean = false + def asTerm: TermSymbol = asInstanceOf[TermSymbol] + def asType: TypeSymbol = asInstanceOf[TypeSymbol] + def asClass: ClassSymbol = asInstanceOf[ClassSymbol] + + /** A unique, densely packed integer tag for each class symbol, -1 + * for all other symbols. To save memory, this method + * should be called only if class is a super class of some other class. + */ + def superId: Int = -1 + +// --------- Forwarders for sym methods -------------------------- + /** Special case tests for flags that are known a-priori and do not need loading * flags. */ @@ -53,19 +69,11 @@ object Symbols { def isPackageObj(implicit ctx: Context) = denot.isPackageObj def isPackageClass(implicit ctx: Context) = denot.isPackageClass - /** A unique, densely packed integer tag for each class symbol, -1 - * for all other symbols. To save memory, this method - * should be called only if class is a super class of some other class. - */ - def superId: Int = -1 - -// --------- Forwarders for sym methods -------------------------- - /** The current owner of this symbol */ final def owner(implicit ctx: Context): Symbol = denot.owner /** The current name of this symbol */ - final def name(implicit ctx: Context): Name = denot.name + final def name(implicit ctx: Context): Name = denot.name.asInstanceOf[Name] /** The current type info of this symbol */ final def info(implicit ctx: Context): Type = denot.info @@ -96,14 +104,34 @@ object Symbols { /** The package containing this symbol */ def enclosingPackage(implicit ctx: Context): Symbol = denot.enclosingPackage + /** The source or class file from which this symbol was generated, null if not applicable. */ final def associatedFile(implicit ctx: Context): AbstractFile = denot.associatedFile + + /** The class file from which this symbol was generated, null if not applicable. */ final def binaryFile(implicit ctx: Context): AbstractFile = denot.binaryFile + + /** The source or class file from which this symbol was generated, null if not applicable. */ final def sourceFile(implicit ctx: Context): AbstractFile = denot.sourceFile + /** Is this symbol defined in the same compilation unit as that symbol? */ + final def isCoDefinedWith(that: Symbol)(implicit ctx: Context): Boolean = denot.isCoDefinedWith(that) + + /** The class with the same (type-) name as this module or module class, + * which is the defined in the same compilation unit. + * NoSymbol if this class does not exist. + */ final def companionClass(implicit ctx: Context): Symbol = denot.companionClass + /** The module object with the same (term-) name as this class or module class, + * which is the defined in the same compilation unit. + * NoSymbol if this class does not exist. + */ final def companionModule(implicit ctx: Context): Symbol = denot.companionModule + /** If this is a class, the module class of its companion object. + * If this is a module class, its companion class. + * NoSymbol otherwise. + */ final def linkedClass(implicit ctx: Context): Symbol = denot.linkedClass /** Is this symbol a subclass of the given class? */ @@ -168,66 +196,84 @@ object Symbols { def showLocated(implicit ctx: Context): String = ctx.printer.showLocated(this) def showDef(implicit ctx: Context): String = ctx.printer.showDef(this) - def typeParams: List[TypeSymbol] = ??? - def unsafeTypeParams: List[TypeSymbol] = ??? - def thisType: Type = ??? - def isStaticMono = isStatic && typeParams.isEmpty - def isRoot: Boolean = ??? - def moduleClass: Symbol = ??? - def cloneSymbol: Symbol = ??? - def hasAnnotation(ann: Annotation): Boolean = ??? - def hasAnnotation(ann: ClassSymbol): Boolean = ??? - - def asTerm: TermSymbol = ??? - def asType: TypeSymbol = ??? - def asClass: ClassSymbol = ??? - def isStatic: Boolean = ??? - def isTypeParameter: Boolean = ??? - def isOverridable: Boolean = ??? - def isCovariant: Boolean = ??? - def isContravariant: Boolean = ??? - def isSkolem: Boolean = ??? - def isDeferred: Boolean = ??? - def isConcrete = !isDeferred - def isJava: Boolean = ??? - - def isAbstractType: Boolean = ??? - def newAbstractType(name: TypeName, info: TypeBounds): TypeSymbol = ??? - def newAbstractTerm(name: TermName, tpe: Type): TypeSymbol = ??? + /** The type parameters of a class symbol, Nil for all other symbols */ + def typeParams(implicit ctx: Context): List[TypeSymbol] = denot.typeParams - //def isMethod(implicit ctx: Context): Boolean = denot.isMethod + /** The type This(cls), where cls is this class symbol */ + def thisType(implicit ctx: Context): Type = denot.thisType + /** Is this symbol the root class or its companion object? */ + def isRoot(implicit ctx: Context): Boolean = denot.isRoot + + /** If this is a module symbol, the class defining its template, otherwise NoSymbol. */ + def moduleClass(implicit ctx: Context): Symbol = denot.moduleClass + + /** A copy of this symbol with the same denotation */ + def copy(implicit ctx: Context): Symbol = unsupported("copy") + + /** A copy of this symbol with the same denotation but a new owner */ + def copy(owner: Symbol)(implicit ctx: Context): Symbol = unsupported("copy") + + /** Can a term with this symbol be a stable value? */ def isStable(implicit ctx: Context): Boolean = denot.isStable + /** Is this symbol static (i.e. with no outer instance)? */ + def isStatic(implicit ctx: Context): Boolean = denot.isStatic + + /** Does this symbol denote a class that defines static symbols? */ + final def isStaticOwner(implicit ctx: Context): Boolean = denot.isStaticOwner + +// def isOverridable: Boolean = !!! need to enforce that classes cannot be redefined + +// def isSkolem: Boolean = ??? + +// def isAbstractType: Boolean = ??? +// def newAbstractType(name: TypeName, info: TypeBounds): TypeSymbol = ??? +// def newAbstractTerm(name: TermName, tpe: Type): TypeSymbol = ??? + + //def isMethod(implicit ctx: Context): Boolean = denot.isMethod + + } - abstract class TermSymbol(denotf: Symbol => SymDenotation) extends Symbol(denotf) { - def name: TermName + class TermSymbol(denotf: Symbol => SymDenotation) extends Symbol(denotf) { + type Name = TermName override def isTerm = true + override def copy(implicit ctx: Context): TermSymbol = copy(owner) + override def copy(owner: Symbol)(implicit ctx: Context): TermSymbol = new TermSymbol(denot.copy(_, owner)) } - abstract class TypeSymbol(denotf: Symbol => SymDenotation) extends Symbol(denotf) { - def name: TypeName + class TypeSymbol(denotf: Symbol => SymDenotation) extends Symbol(denotf) { + type Name = TypeName override def isType = true + override def copy(implicit ctx: Context): TypeSymbol = copy(owner) + override def copy(owner: Symbol)(implicit ctx: Context): TypeSymbol = new TypeSymbol(denot.copy(_, owner)) - def variance: Int = ??? + /** The type representing the type constructor for this type symbol */ + def typeConstructor(implicit ctx: Context): Type = denot.typeConstructor - def typeConstructor(implicit ctx: Context): Type = ??? - def typeTemplate(implicit ctx: Context): Type = ??? + /** The variance of this type parameter as an Int, with + * +1 = Covariant, -1 = Contravariant, 0 = Nonvariant + */ + def variance(implicit ctx: Context): Int = denot.variance } - abstract class ClassSymbol(denotf: Symbol => ClassDenotation) extends TypeSymbol(denotf) { + class ClassSymbol(denotf: ClassSymbol => ClassDenotation) extends TypeSymbol(s => denotf(s.asClass)) { override def isClass = true + override def copy(implicit ctx: Context): ClassSymbol = copy(owner) + override def copy(owner: Symbol)(implicit ctx: Context): ClassSymbol = new ClassSymbol(classDenot.copyClass(_, owner)) private var superIdHint: Int = -1 final def classDenot(implicit ctx: Context): ClassDenotation = denot.asInstanceOf[ClassDenotation] - def typeOfThis(implicit ctx: Context): Type = ??? + def selfType(implicit ctx: Context): Type = classDenot.selfType + /** The base classes of this class in linearization order, + * with the class itself as first element.x + */ def baseClasses(implicit ctx: Context): List[ClassSymbol] = classDenot.baseClasses - override def typeConstructor(implicit ctx: Context): Type = classDenot.typeConstructor // override def typeTemplate(implicit ctx: Context): Type = classDenot.typeTemplate def superId(implicit ctx: Context): Int = { diff --git a/src/dotty/tools/dotc/core/TypeComparers.scala b/src/dotty/tools/dotc/core/TypeComparers.scala index be4c0b99c..5c32432d7 100644 --- a/src/dotty/tools/dotc/core/TypeComparers.scala +++ b/src/dotty/tools/dotc/core/TypeComparers.scala @@ -77,7 +77,7 @@ object TypeComparers { || tp1.name == tp2.name && isSubType(pre1, pre2) && - (sym2.isAbstractType || isSubType(pre2, pre1)) // ??? + (sym2.info.isRealTypeBounds || isSubType(pre2, pre1)) // ??? || (sym2.isClass) && { val base = tp1.baseType(sym2) diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala index 25c8625ec..5e25ab4a9 100644 --- a/src/dotty/tools/dotc/core/TypeOps.scala +++ b/src/dotty/tools/dotc/core/TypeOps.scala @@ -1,6 +1,6 @@ package dotty.tools.dotc.core -import Contexts._, Types._, Symbols._, Names._ +import Contexts._, Types._, Symbols._, Names._, Flags._ trait TypeOps { this: Context => @@ -31,7 +31,7 @@ trait TypeOps { this: Context => if (pre1 eq pre0) tp else { val tp1 = NamedType(pre1, tp.name) - if (sym.isTypeParameter) { + if (sym is TypeParam) { // short-circuit instantiated type parameters // by replacing pre.tp with its alias, if it has one. val tp2 = tp1.info diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala index ee9e881ad..dcef49d0d 100644 --- a/src/dotty/tools/dotc/core/Types.scala +++ b/src/dotty/tools/dotc/core/Types.scala @@ -198,9 +198,9 @@ object Types { final def subst(from: BindingType, to: BindingType)(implicit ctx: Context): Type = ctx.subst(this, from, to, null) - /** Substitute all occurrences of `This(clazz)` by `tp` */ - final def substThis(clazz: ClassSymbol, tp: Type)(implicit ctx: Context): Type = - ctx.substThis(this, clazz, tp, null) + /** Substitute all occurrences of `This(cls)` by `tp` */ + final def substThis(cls: ClassSymbol, tp: Type)(implicit ctx: Context): Type = + ctx.substThis(this, cls, tp, null) /** Substitute all occurrences of `RefinedThis(rt)` by `tp` */ final def substThis(rt: RefinedType, tp: Type)(implicit ctx: Context): Type = @@ -378,9 +378,9 @@ object Types { //def resultType: Type = ??? - /** The base classes of this type as determined by ClassDenotation. - * Inherited by all type proxies. - * `Nil` for all other types. + /** The base classes of this type as determined by ClassDenotation + * in linearization order, with the class itself as first element. + * Inherited by all type proxies. `Nil` for all other types. */ final def baseClasses(implicit ctx: Context): List[ClassSymbol] = this match { case tp: TypeProxy => @@ -390,11 +390,11 @@ object Types { case _ => Nil } - final def asSeenFrom(pre: Type, clazz: Symbol)(implicit ctx: Context): Type = - if (clazz.isStaticMono || - ctx.erasedTypes && clazz != defn.ArrayClass || - (pre eq clazz.thisType)) this - else ctx.asSeenFrom(this, pre, clazz, null) + final def asSeenFrom(pre: Type, cls: Symbol)(implicit ctx: Context): Type = + if ((cls is PackageClass) || + ctx.erasedTypes && cls != defn.ArrayClass || + (pre eq cls.thisType)) this + else ctx.asSeenFrom(this, pre, cls, null) /** The signature of this type. This is by default NullSignature, * but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. @@ -564,8 +564,8 @@ object Types { private[this] var lastDenotation: Denotation = null - private def checkPrefix(sym: Symbol) = - sym.isAbstractType || sym.isClass + private def checkPrefix(denot: Denotation) = + denot.info.isRealTypeBounds || denot.symbol.isClass /** The denotation currently denoted by this type */ def denot(implicit ctx: Context): Denotation = { @@ -579,7 +579,7 @@ object Types { } else { val d = loadDenot if (d.exists || ctx.phaseId == FirstPhaseId) { - if (checkPrefix(d.symbol) && !prefix.isLegalPrefix) + if (checkPrefix(d) && !prefix.isLegalPrefix) throw new MalformedType(prefix, d.symbol) d } else {// name has changed; try load in earlier phase and make current @@ -661,16 +661,18 @@ object Types { // --- Other SingletonTypes: ThisType/SuperType/ConstantType --------------------------- - abstract case class ThisType(clazz: ClassSymbol) extends CachedProxyType with SingletonType { - override def underlying(implicit ctx: Context) = clazz.typeOfThis - override def computeHash = doHash(clazz) + abstract case class ThisType(cls: ClassSymbol) extends CachedProxyType with SingletonType { + override def underlying(implicit ctx: Context) = cls.selfType + override def computeHash = doHash(cls) } - final class CachedThisType(clazz: ClassSymbol) extends ThisType(clazz) + final class CachedThisType(cls: ClassSymbol) extends ThisType(cls) object ThisType { - def apply(clazz: ClassSymbol)(implicit ctx: Context) = - unique(new CachedThisType(clazz)) + def apply(cls: ClassSymbol)(implicit ctx: Context) = { + assert(!(cls is PackageClass) || cls.isRoot) + unique(new CachedThisType(cls)) + } } abstract case class SuperType(thistpe: Type, supertpe: Type) extends CachedProxyType with SingletonType { @@ -1116,7 +1118,7 @@ object Types { /** A filter for names of deferred term definitions of a given type */ object abstractTermNameFilter extends NameFilter { def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = - name.isTermName && (pre member name).symbol.isDeferred + name.isTermName && ((pre member name).symbol is Deferred) } // ----- Exceptions ------------------------------------------------------------- -- cgit v1.2.3