xtext: efficient way for custom Scoping - customization

Question

I tried to custom Scoping like this:
In the file MyDslScopeProvider that extends AbstractMyDslScopeProvider,
I implemented the function with this signature:
override def IScope getScope(EObject context, EReference reference)
and I used cases like this
if (reference == SpectraPackage.Literals.SOMETHING__POINTER)
but I have function in my grammar that it's have parameters and we can declare inside local vars. I don't want that those local vars and the parameters of that function would be visible from the outside, I want them to be visible only inside the function so I did something like this:
if (contextDecl instanceof function) {
val fun= contextDecl as function
val allContentsCurrFile = EcoreUtil2.getAllContentsOfType(fun,Constant)
EObjectsInScope.addAll(fun.params)
EObjectsInScope.addAll(allContentsCurrFile)
return Scopes.scopeFor(EObjectsInScope)
}
else{
val removeEobjects = newArrayList()
EObjectsInScope.addAll(EcoreUtil2.getAllContentsOfType(root,EObject))
val funList= EcoreUtil2.getAllContentsOfType(root,function) as List<function>
for(function f: funList){
removeEobjects.addAll(f.varDeclList)
removeEobjects.addAll(f.params.params)
removeEobjects.addAll(EcoreUtil2.getAllContentsOfType(f,Constant))
}
EObjectsInScope.removeAll(removeEobjects)
return Scopes.scopeFor(EObjectsInScope)
This is very un-efficient to get all the EObjects and to remove the vars that I don't want to be visible from the outside (it's taking a lot of time).
There is a way to do this more efficient?
Thanks.

Answer 1

EDIT: You might also be interested in my answer to "Xtext: IResourceScopeCache for Avoid expensive scope calculation"
First of all, if you are talking about local variables, you probably don't want to allow using local variables before they are declared, e.g.
function foo() {
x = x + 1;
int x = 0;
}
So you are actually doing too much work by using getAllContentsOfType().
What exactly are you trying to achieve using your optimizations? Better performance for content assist inside a function? Better speed for large number of models with small functions bodies? Better speed for many large functions?
Keep in mind to avoid premature optimization - it is more important to keep your code maintainable, and optimize for speed only if it doesn't scale to the workloads you actually need to handle. Did you use a profiler to find Hotspots? Human intuition can be pretty wrong when it comes to performance bottlenecks.
Anyway, under the assumption that you need to improve speed of scoping but you don't have massive workloads, as a first shot, I'd suggest using a TreeIterator to traverse the function body collecting the local variables that should be visible, and, using the return value of EcoreUtil2.getAllContainers(context) as a guide when to use prune() and when to use next().
I.e.
import static extension org.eclipse.xtext.EcoreUtil2.*
// ...
val predecessors = new ArrayList<EObject>
val iterator = EcoreUtils.getAllContents(function, true)
// Could be optimized further
val descentGuide = context.allContainers.dropWhile[it != function].toList.reverseView.iterator
var current = iterator.next
var nextDescent = descentGuide.next
while(current != context) {
// collect list with local variables here
predecessors += current
if(current == nextDescent) {
// Reached another ancestor of context - will look for the following ancestor next
nextDescent = descentGuide.next
} else {
iterator.prune
}
current = iterator.next
}
// Reverse so innermost declarations shadow outer declarations
val localVariables = predecessors.filter(LocalVariableDeclaration).toList.reverseView
I didn't compile/test the code, but I hope the idea becomes clear.
The while loop should terminate in the end because at some point, context will be reached -- but to be more robust it might make sense to add && iterator.hasNext to the while loop.