@@ -18,72 +18,81 @@ trait Importers { self: SymbolTable =>
18
18
def importPosition (pos : from.Position ): Position = NoPosition
19
19
20
20
def importSymbol (sym : from.Symbol ): Symbol = {
21
- def importOrRelink : Symbol =
22
- if (sym == null )
23
- null
24
- else if (sym.getClass == NoSymbol .getClass)
25
- NoSymbol
26
- else if (sym.isRoot)
27
- definitions.RootClass
28
- else {
29
- val myowner = importSymbol(sym.owner)
30
- val mypos = importPosition(sym.pos)
31
- val myname = importName(sym.name)
32
-
33
- def doImport : Symbol = {
34
- val mysym = sym match {
35
- case x : from.MethodSymbol =>
36
- val mysym = new MethodSymbol (myowner, mypos, myname)
37
- mysym.referenced = importSymbol(x.referenced)
38
- mysym
39
- case x : from.ModuleSymbol =>
40
- new ModuleSymbol (myowner, mypos, myname)
41
- case x : from.FreeVar =>
42
- new FreeVar (importName(x.name), importType(x.tpe), x.value)
43
- case x : from.TermSymbol =>
44
- new TermSymbol (myowner, mypos, myname)
45
- case x : from.TypeSkolem =>
46
- new TypeSkolem (myowner, mypos, myname.toTypeName, x.unpackLocation match {
47
- case null => null
48
- case y : from.Tree => importTree(y)
49
- case y : from.Symbol => importSymbol(y)
50
- })
51
- /*
21
+ def doImport (sym : from.Symbol ): Symbol = {
22
+ val myowner = importSymbol(sym.owner)
23
+ val mypos = importPosition(sym.pos)
24
+ val myname = importName(sym.name)
25
+ def linkReferenced (mysym : TermSymbol , x : from.TermSymbol , op : from.Symbol => Symbol ): Symbol = {
26
+ println(" link referenced " + mysym + " " + x.referenced)
27
+ symMap(x) = mysym
28
+ mysym.referenced = op(x.referenced)
29
+ mysym
30
+ }
31
+ val mysym = sym match {
32
+ case x : from.MethodSymbol =>
33
+ linkReferenced(new MethodSymbol (myowner, mypos, myname), x, importSymbol)
34
+ case x : from.ModuleSymbol =>
35
+ linkReferenced(new ModuleSymbol (myowner, mypos, myname), x, doImport)
36
+ case x : from.FreeVar =>
37
+ new FreeVar (importName(x.name), importType(x.tpe), x.value)
38
+ case x : from.TermSymbol =>
39
+ linkReferenced(new TermSymbol (myowner, mypos, myname), x, importSymbol)
40
+ case x : from.TypeSkolem =>
41
+ new TypeSkolem (myowner, mypos, myname.toTypeName, x.unpackLocation match {
42
+ case null => null
43
+ case y : from.Tree => importTree(y)
44
+ case y : from.Symbol => importSymbol(y)
45
+ })
46
+ /*
52
47
case x: from.ModuleClassSymbol =>
53
48
val mysym = new ModuleClassSymbol(myowner, mypos, myname.toTypeName)
54
49
mysym.sourceModule = importSymbol(x.sourceModule)
55
50
mysym
56
51
*/
57
- case x : from.ClassSymbol =>
58
- val mysym = new ClassSymbol (myowner, mypos, myname.toTypeName)
59
- if (sym.thisSym != sym) {
60
- mysym.typeOfThis = importType(sym.typeOfThis)
61
- mysym.thisSym.name = importName(sym.thisSym.name)
62
- }
63
- mysym
64
- case x : from.TypeSymbol =>
65
- new TypeSymbol (myowner, mypos, myname.toTypeName)
52
+ case x : from.ClassSymbol =>
53
+ val mysym = new ClassSymbol (myowner, mypos, myname.toTypeName)
54
+ if (sym.thisSym != sym) {
55
+ mysym.typeOfThis = importType(sym.typeOfThis)
56
+ mysym.thisSym.name = importName(sym.thisSym.name)
66
57
}
67
- symMap(sym) = mysym
68
- mysym setFlag sym.flags | Flags . LOCKED
69
- mysym setInfo {
70
- val mytypeParams = sym.typeParams map importSymbol
71
- new LazyPolyType (mytypeParams) {
72
- override def complete ( s : Symbol ) {
73
- val result = sym.info match {
74
- case from. PolyType (_, res) => res
75
- case result => result
76
- }
77
- s setInfo polyType(mytypeParams, importType(result))
78
- s setAnnotations (sym.annotations map importAnnotationInfo)
79
- }
58
+ mysym
59
+ case x : from. TypeSymbol =>
60
+ new TypeSymbol (myowner, mypos, myname.toTypeName)
61
+ }
62
+ symMap(sym) = mysym
63
+ mysym setFlag sym.flags | Flags . LOCKED
64
+ mysym setInfo {
65
+ val mytypeParams = sym.typeParams map doImport
66
+ new LazyPolyType (mytypeParams) {
67
+ override def complete ( s : Symbol ) {
68
+ val result = sym.info match {
69
+ case from. PolyType (_, res) => res
70
+ case result => result
80
71
}
72
+ s setInfo polyType(mytypeParams, importType(result))
73
+ s setAnnotations (sym.annotations map importAnnotationInfo)
81
74
}
82
- mysym resetFlag Flags .LOCKED
83
- } // end doImport
75
+ }
76
+ }
77
+ mysym resetFlag Flags .LOCKED
78
+ } // end doImport
84
79
80
+ def importOrRelink : Symbol =
81
+ if (sym == null )
82
+ null
83
+ else if (sym == from.NoSymbol )
84
+ NoSymbol
85
+ else if (sym.isRoot)
86
+ definitions.RootClass
87
+ else {
88
+ val myowner = importSymbol(sym.owner)
89
+ val myname = importName(sym.name)
85
90
if (sym.isModuleClass) {
86
- importSymbol(sym.sourceModule).moduleClass
91
+ assert(sym.sourceModule != NoSymbol , sym)
92
+ val mymodule = importSymbol(sym.sourceModule)
93
+ assert(mymodule != NoSymbol , sym)
94
+ assert(mymodule.moduleClass != NoSymbol , mymodule)
95
+ mymodule.moduleClass
87
96
} else if (myowner.isClass && ! myowner.isRefinementClass && ! (myowner hasFlag Flags .LOCKED ) && sym.owner.info.decl(sym.name).exists) {
88
97
// symbol is in class scope, try to find equivalent one in local scope
89
98
if (sym.isOverloaded)
@@ -93,7 +102,7 @@ trait Importers { self: SymbolTable =>
93
102
if (existing.isOverloaded) {
94
103
existing =
95
104
if (sym.isMethod) {
96
- val localCopy = doImport
105
+ val localCopy = doImport(sym)
97
106
existing filter (_.tpe matches localCopy.tpe)
98
107
} else {
99
108
existing filter (! _.isMethod)
@@ -104,7 +113,7 @@ trait Importers { self: SymbolTable =>
104
113
}
105
114
if (existing != NoSymbol ) existing
106
115
else {
107
- val mysym = doImport
116
+ val mysym = doImport(sym)
108
117
assert(myowner.info.decls.lookup(myname) == NoSymbol , myname+ " " + myowner.info.decl(myname)+ " " + existing)
109
118
myowner.info.decls enter mysym
110
119
mysym
@@ -118,7 +127,7 @@ trait Importers { self: SymbolTable =>
118
127
println(myowner.rawInfo)
119
128
myowner.typeParams(sym.paramPos)
120
129
} else
121
- doImport
130
+ doImport(sym)
122
131
}
123
132
symMap getOrElseUpdate (sym, importOrRelink)
124
133
}
0 commit comments