From f7efb9505c0ede48a67fb6a256604ba3ca02bcb3 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Sun, 16 Sep 2012 23:58:30 +0200 Subject: distinguishes flag-agnostic completers At times it's useful to know whether a lazy type can change the flags of the underlying symbol or not. If the completer is flag-agnostic, this means that we can safely use flag-inspection facilities such as hasFlag and isXXX tests without fear of looking into not yet initialized data. --- src/reflect/scala/reflect/internal/Importers.scala | 2 +- src/reflect/scala/reflect/internal/Types.scala | 10 ++++++++++ src/reflect/scala/reflect/internal/pickling/UnPickler.scala | 2 +- src/reflect/scala/reflect/runtime/JavaMirrors.scala | 10 ++++++---- src/reflect/scala/reflect/runtime/SymbolLoaders.scala | 4 ++-- 5 files changed, 20 insertions(+), 8 deletions(-) (limited to 'src/reflect/scala') diff --git a/src/reflect/scala/reflect/internal/Importers.scala b/src/reflect/scala/reflect/internal/Importers.scala index c116928d37..893d039c3e 100644 --- a/src/reflect/scala/reflect/internal/Importers.scala +++ b/src/reflect/scala/reflect/internal/Importers.scala @@ -104,7 +104,7 @@ trait Importers extends api.Importers { self: SymbolTable => mysym setFlag Flags.LOCKED mysym setInfo { val mytypeParams = sym.typeParams map importSymbol - new LazyPolyType(mytypeParams) { + new LazyPolyType(mytypeParams) with FlagAgnosticCompleter { override def complete(s: Symbol) { val result = sym.info match { case from.PolyType(_, res) => res diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index ee488c9d18..ac8a0d97ee 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -3480,6 +3480,16 @@ trait Types extends api.Types { self: SymbolTable => override def kind = "LazyType" } + /** A marker trait representing an as-yet unevaluated type + * which doesn't assign flags to the underlying symbol. + */ + trait FlagAgnosticCompleter extends LazyType + + /** A marker trait representing an as-yet unevaluated type + * which assigns flags to the underlying symbol. + */ + trait FlagAssigningCompleter extends LazyType + abstract class LazyPolyType(override val typeParams: List[Symbol]) extends LazyType { override def safeToString = (if (typeParams.isEmpty) "" else typeParamsString(this)) + super.safeToString diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala index a9994a037f..b158a1ac26 100644 --- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala +++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala @@ -848,7 +848,7 @@ abstract class UnPickler /*extends scala.reflect.generic.UnPickler*/ { } /** A lazy type which when completed returns type at index `i`. */ - private class LazyTypeRef(i: Int) extends LazyType { + private class LazyTypeRef(i: Int) extends LazyType with FlagAgnosticCompleter { private val definedAtRunId = currentRunId private val p = phase override def complete(sym: Symbol) : Unit = try { diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala index 0d9e90d3a6..16a684a08d 100644 --- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala +++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala @@ -44,6 +44,8 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { thisUnive // overriden by ReflectGlobal def rootClassLoader: ClassLoader = this.getClass.getClassLoader + trait JavaClassCompleter extends FlagAssigningCompleter + def init() = { definitions.AnyValClass // force it. @@ -71,7 +73,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { thisUnive /** The lazy type for root. */ - override lazy val rootLoader = new LazyType { + override lazy val rootLoader = new LazyType with FlagAgnosticCompleter { override def complete(sym: Symbol) = sym setInfo new LazyPackageType } @@ -609,7 +611,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { thisUnive * A completer that fills in the type of a Scala type parameter from the bounds of a Java type variable. * @param jtvar The Java type variable */ - private class TypeParamCompleter(jtvar: jTypeVariable[_ <: GenericDeclaration]) extends LazyType { + private class TypeParamCompleter(jtvar: jTypeVariable[_ <: GenericDeclaration]) extends LazyType with FlagAgnosticCompleter { override def load(sym: Symbol) = complete(sym) override def complete(sym: Symbol) = { sym setInfo TypeBounds.upper(glb(jtvar.getBounds.toList map typeToScala map objToAny)) @@ -634,7 +636,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { thisUnive * @param module The Scala companion object for which info is copied * @param jclazz The Java class */ - private class FromJavaClassCompleter(clazz: Symbol, module: Symbol, jclazz: jClass[_]) extends LazyType { + private class FromJavaClassCompleter(clazz: Symbol, module: Symbol, jclazz: jClass[_]) extends LazyType with JavaClassCompleter with FlagAssigningCompleter { /** used to avoid cycles while initializing classes */ private var parentsLevel = 0 @@ -710,7 +712,7 @@ trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse { thisUnive } } - class LazyPolyType(override val typeParams: List[Symbol]) extends LazyType { + class LazyPolyType(override val typeParams: List[Symbol]) extends LazyType with FlagAgnosticCompleter { override def complete(sym: Symbol) { completeRest() } diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala index f3473d46a7..d1be73bed3 100644 --- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala +++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala @@ -14,7 +14,7 @@ trait SymbolLoaders { self: SymbolTable => * by unpickling information from the corresponding Java class. If no Java class * is found, a package is created instead. */ - class TopClassCompleter(clazz: Symbol, module: Symbol) extends SymLoader { + class TopClassCompleter(clazz: Symbol, module: Symbol) extends SymLoader with FlagAssigningCompleter { // def makePackage() { // println("wrong guess; making package "+clazz) // val ptpe = newPackageType(module.moduleClass) @@ -80,7 +80,7 @@ trait SymbolLoaders { self: SymbolTable => /** The type completer for packages. */ - class LazyPackageType extends LazyType { + class LazyPackageType extends LazyType with FlagAgnosticCompleter { override def complete(sym: Symbol) { assert(sym.isPackageClass) sym setInfo new ClassInfoType(List(), new PackageScope(sym), sym) -- cgit v1.2.3