Hi Dominic,
Dominic Evans wrote:
> In Scope.java, findTransitiveReference seems to loop over all symbols,
> resolving to assign Symbol symbol, and in the end returns just this one
> symbol. A lot of time seems to be spent in this method.
>
> What is the purpose? To find the last TypeSymbol and resolve that?
this method is supposed to handle transitive imported symbols if i
remember correctly. for example:
module foo {
import from bar all;
function test() {
var foostring foostringVar := "test";
}
}
module bar {
import from blah all;
type foostring mystring;
}
module blah {
type charstring foostring;
}
without transitive imports, foostring would not be resolvable in module
foo, because foo imports only from bar and not from module blah.
however, mystring is imported and it references foostring, so foostring
is imported transitively.
the currently implemented solution may be a little too simple, i admit.
it basically works this way:
if a symbol is not resolvable in a scope, the last step is to check each
type symbol in the symbol table. if it has a referenced type with the
same name as the symbol to be resolved, the symbol is resolved again
using the scope of the type definition where it is referenced.
there is a problem with this implementation: it doesn't resolve all
transitive symbols. it was more or less a quick hack. for example:
modules A-B-C (i.e. A imports from B, B imports from C):
A can access transitively imported symbols from C with this
implementation, but
modules A-B-C-D:
A can't access transitively imported symbols from D. that is, because
module B is inspected for referenced types with matching names which
only appear in module C.
This is definately something that needs to be fixed at some point.
However, i haven't seen any module that uses the feature this much and i
guess a real fix would take a little time.
for the moment (and a quick fix), it would probably be a speedup if each
scope would have an additional hashmap which stores referenced type
names as key and the corresponding type symbol as value. that way, the
lookup is just O(1) and not O(n) for each scope.
--
Benjamin Zeiss
--
Benjamin Zeiss