how to resolve different kinds of nodes in different contexts?

[BrianHicks]

I'm getting started using stack-graphs to provide jumps for Elm. I'm curious how to approach the following situation: in Elm, you can define a tagged union type with a tag with the same name as the type. Here's what I expect a test would look like:

type Foo
    = Foo

foo : Foo
   -- ^ defined: 1
foo =
    Foo
 -- ^ defined: 2

How would I annotate the graph to get this behavior?

[BrianHicks]

ah, I think I figured it out: use a different resolution scope. Instead of lexical_scope/lexical_defs I can use type_scope/type_defs 👍

[hendrikvanantwerpen]

Hi @BrianHicks! Great to see you trying this out :)

Your suggestion is indeed an option to solve this problem. The downside might be that you can end up duplicating the structure for every namespace you want to support.

Another possibility that we often use is to have a single scoping structure (the lexical_* nodes in this case), but use what we call guard nodes to separate the namespaces. The graph structure would look something like this:

[reference NAME] -> [push NAMESPACE] -> ... -> [pop NAMESPACE] -> [definition NAME]

In the rules, you'd get something like the following for e.g. type references:

node ref
attr (ref) node_reference = @name

node ns
attr (ns) push_symbol = "%type"

edge ref -> ns
edge ns -> @xxx.lexical_scope

And the inverse for type declarations:

node def
attr (def) node_definition = @namzo 

node ns
attr (ns) pop_node = "%type"

edge @xxx.lexical_defs -> ns
edge ns -> def

It's important that the symbol used for the namespaces (%type in this example) cannot appear as a symbol in source, to prevent clashes. (And I'm using some attribute shorthands we usually define, in case you haven't seen those before.)

Let me know if this helps!