@@ -17,30 +17,30 @@ import pickling.ClassfileParser
17
17
/** A base class for Symbol loaders with some overridable behavior */
18
18
class SymbolLoaders {
19
19
20
- protected def enterIfNew (owner : Symbol , member : Symbol , completer : SymbolLoader )(implicit ctx : Context ): Symbol = {
20
+ protected final def enterIfNew (owner : Symbol , member : Symbol , completer : SymbolLoader )(implicit ctx : Context ): Symbol = {
21
21
assert(owner.info.decls.lookup(member.name) == NoSymbol , owner.fullName + " ." + member.name)
22
22
owner.info.decls enter member
23
23
member
24
24
}
25
25
26
26
/** Enter class with given `name` into scope of `owner`.
27
27
*/
28
- def enterClass (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ): Symbol = {
28
+ final def enterClass (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ): Symbol = {
29
29
val cls = ctx.newLazyClassSymbol(owner, name.toTypeName, flags, completer, assocFile = completer.sourceFileOrNull)
30
30
enterIfNew(owner, cls, completer)
31
31
}
32
32
33
33
/** Enter module with given `name` into scope of `owner`.
34
34
*/
35
- def enterModule (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ): Symbol = {
35
+ final def enterModule (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ): Symbol = {
36
36
val module = ctx.newLazyModuleSymbols(owner, name.toTermName, flags, completer, assocFile = completer.sourceFileOrNull)._1
37
37
enterIfNew(owner, module, completer)
38
38
}
39
39
40
40
/** Enter package with given `name` into scope of `owner`
41
41
* and give them `completer` as type.
42
42
*/
43
- def enterPackage (owner : Symbol , name : PreName , completer : SymbolLoader )(implicit ctx : Context ): Symbol = {
43
+ final def enterPackage (owner : Symbol , name : PreName , completer : SymbolLoader )(implicit ctx : Context ): Symbol = {
44
44
val pname = name.toTermName
45
45
val preExisting = owner.info.decls lookup pname
46
46
if (preExisting != NoSymbol ) {
@@ -69,7 +69,7 @@ class SymbolLoaders {
69
69
/** Enter class and module with given `name` into scope of `owner`
70
70
* and give them `completer` as type.
71
71
*/
72
- def enterClassAndModule (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ) {
72
+ final def enterClassAndModule (owner : Symbol , name : PreName , completer : SymbolLoader , flags : FlagSet = EmptyFlags )(implicit ctx : Context ) {
73
73
val clazz = enterClass(owner, name, completer, flags)
74
74
val module = enterModule(owner, name, completer, flags)
75
75
if (! clazz.isAnonymousClass) {
@@ -84,7 +84,7 @@ class SymbolLoaders {
84
84
* with source completer for given `src` as type.
85
85
* (overridden in interactive.Global).
86
86
*/
87
- def enterToplevelsFromSource (owner : Symbol , name : PreName , src : AbstractFile )(implicit ctx : Context ) {
87
+ final def enterToplevelsFromSource (owner : Symbol , name : PreName , src : AbstractFile )(implicit ctx : Context ) {
88
88
??? // !!! enterClassAndModule(owner, name, new SourcefileLoader(src))
89
89
}
90
90
@@ -95,13 +95,13 @@ class SymbolLoaders {
95
95
* Note: We do a name-base comparison here because the method is called before we even
96
96
* have ReflectPackage defined.
97
97
*/
98
- def binaryOnly (owner : Symbol , name : String )(implicit ctx : Context ): Boolean =
98
+ final def binaryOnly (owner : Symbol , name : String )(implicit ctx : Context ): Boolean =
99
99
name == " package" &&
100
100
(owner.fullName == " scala" || owner.fullName == " scala.reflect" )
101
101
102
102
/** Initialize toplevel class and module symbols in `owner` from class path representation `classRep`
103
103
*/
104
- def initializeFromClassPath (owner : Symbol , classRep : ClassPath # ClassRep )(implicit ctx : Context ) {
104
+ final def initializeFromClassPath (owner : Symbol , classRep : ClassPath # ClassRep )(implicit ctx : Context ) {
105
105
((classRep.binary, classRep.source): @ unchecked) match {
106
106
case (Some (bin), Some (src)) if needCompile(bin, src) && ! binaryOnly(owner, classRep.name) =>
107
107
if (ctx.settings.verbose.value) ctx.inform(" [symloader] picked up newer source file for " + src.path)
@@ -114,12 +114,12 @@ class SymbolLoaders {
114
114
}
115
115
}
116
116
117
- def needCompile (bin : AbstractFile , src : AbstractFile ) =
117
+ final def needCompile (bin : AbstractFile , src : AbstractFile ) =
118
118
src.lastModified >= bin.lastModified
119
119
120
120
/** Load contents of a package
121
121
*/
122
- class PackageLoader (classpath : ClassPath )(cctx : CondensedContext ) extends SymbolLoader {
122
+ final class PackageLoader (classpath : ClassPath )(cctx : CondensedContext ) extends SymbolLoader {
123
123
implicit val ctx : Context = cctx
124
124
protected def description = " package loader " + classpath.name
125
125
@@ -151,7 +151,7 @@ class SymbolLoaders {
151
151
* Todo: consider factoring out behavior from TopClassCompleter/SymbolLoader into
152
152
* supertrait SymLoader
153
153
*/
154
- abstract class SymbolLoader extends ClassCompleter {
154
+ sealed abstract class SymbolLoader extends ClassCompleter {
155
155
implicit val ctx : Context
156
156
157
157
/** Load source or class file for `root`, return */
@@ -164,7 +164,7 @@ abstract class SymbolLoader extends ClassCompleter {
164
164
*/
165
165
protected def description : String
166
166
167
- override def apply (root : LazyClassDenotation ) = {
167
+ override final def apply (root : LazyClassDenotation ) = {
168
168
def signalError (ex : Exception ) {
169
169
if (ctx.settings.debug.value) ex.printStackTrace()
170
170
val msg = ex.getMessage()
@@ -187,7 +187,7 @@ abstract class SymbolLoader extends ClassCompleter {
187
187
}
188
188
}
189
189
190
- class ClassfileLoader (val classfile : AbstractFile )(cctx : CondensedContext ) extends SymbolLoader {
190
+ final class ClassfileLoader (val classfile : AbstractFile )(cctx : CondensedContext ) extends SymbolLoader {
191
191
implicit val ctx : Context = cctx
192
192
193
193
override def sourceFileOrNull : AbstractFile = classfile
@@ -209,38 +209,6 @@ class ClassfileLoader(val classfile: AbstractFile)(cctx: CondensedContext) exten
209
209
}
210
210
}
211
211
/*
212
- class MsilFileLoader(msilFile: MsilFile) extends SymbolLoader with FlagAssigningCompleter {
213
- private def typ = msilFile.msilType
214
- private object typeParser extends clr.TypeParser {
215
- val global: SymbolLoaders.this.global.type = SymbolLoaders.this.global
216
- }
217
-
218
- protected def description = "MsilFile "+ typ.FullName + ", assembly "+ typ.Assembly.FullName
219
- protected def doComplete(root: Symbol) { typeParser.parse(typ, root) }
220
- }
221
-
222
- class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader with FlagAssigningCompleter {
223
- protected def description = "source file "+ srcfile.toString
224
- override def fromSource = true
225
- override def sourcefile = Some(srcfile)
226
- protected def doComplete(root: Symbol): Unit = global.currentRun.compileLate(srcfile)
227
- }
228
-
229
- object moduleClassLoader extends SymbolLoader with FlagAssigningCompleter {
230
- protected def description = "module class loader"
231
- protected def doComplete(root: Symbol) { root.sourceModule.initialize }
232
- }
233
-
234
- object clrTypes extends clr.CLRTypes {
235
- val global: SymbolLoaders.this.global.type = SymbolLoaders.this.global
236
- if (global.forMSIL) init()
237
- }
238
-
239
- /** used from classfile parser to avoid cyclies */
240
- var parentsLevel = 0
241
- var pendingLoadActions: List[() => Unit] = Nil
242
- }
243
-
244
212
object SymbolLoadersStats {
245
213
import scala.reflect.internal.TypesStats.typerNanos
246
214
val classReadNanos = Statistics.newSubTimer ("time classfilereading", typerNanos)
0 commit comments