Disable global description inside the local scope

[theogiraudet]

Hello!

First, thanks for your guide about how to do qualified names, it's really helpful!
Thanks to the guide, I created a "module system", to reference entities that are external to the current module by their qualified name:

I still have one question about the possible ways to reference my entities with this new scope system: how can I forbid referencing an entity by its qualified name when it is declared in the same module as where I am?
For instance, if I check the different possibilities for my type in the following screenshot, I only want those who aren't crossed out because I am in the module test2 and the entities Foo and Bar are declared inside:

Here is my custom scope computation service:

export class KernoScopeComputation extends DefaultScopeComputation {
    
    constructor(services: LangiumServices) {
        super(services);
    }

    override async computeExports(document: LangiumDocument): Promise<AstNodeDescription[]> {
        const exportedDescriptions: AstNodeDescription[] = [];
        for (const childNode of streamAllContents(document.parseResult.value)) {
            if (isClassifier(childNode)) {
                const fullyQualifiedName = `${childNode.$container.module}.${childNode.name}`;
                exportedDescriptions.push(this.descriptions.createDescription(childNode, fullyQualifiedName, document));
            }
        }
        return exportedDescriptions;
    }

    override async computeLocalScopes(document: LangiumDocument): Promise<PrecomputedScopes> {
        const model = document.parseResult.value as Model;
        const scopes = new MultiMap<AstNode, AstNodeDescription>();
        this.processContainer(model, scopes, document);
        return scopes;
    }

    private processContainer(container: Model, scopes: PrecomputedScopes, document: LangiumDocument): AstNodeDescription[] {
        const localDescriptions: AstNodeDescription[] = [];
        for (const element of container.namespaces) {
            if (isClassifier(element)) {
                const description = this.descriptions.createDescription(element, element.name, document);
                localDescriptions.push(description);
            }
        }
        scopes.addAll(container, localDescriptions);
        return localDescriptions;
    }

}

Basically, it is the same as in the guide, adapted to my language.
Here is an extract of my grammar types:

interface Model {
    module: string
    namespaces: Classifier[]
}

type Classifier = Entity

interface Entity {
    name: string
    documentation?: Documentation
    members: Member[]
}

Thanks for your help!

[msujew]

Hey @theogiraudet,

Xtext used to have a concept of a FilterScope that accepts a predicate to filter another scope. I think you need something similar here. The main idea would be to override the getGlobalScope method to filter/remove all elements that are local to the element getting scoped. I.e. remove all AstNodeDescription objects from the normal global scope that have the same uri as the current ReferenceInfo. Something similar to this should work:

protected override getGlobalScope(referenceType: string, _context: ReferenceInfo): Scope {
  const globalScope = super.getGlobalScope(referenceType, _context);
  const documentUri = getDocument(_context.container).uri;
  return new FilterScope(globalScope, astDescription => !UriUtils.equals(astDescription, documentUri));     
}

[theogiraudet]

Hey @msujew!
Thanks, it works perfectly :)