What is the simplest way to detect variable shadowing?

[aabounegm]

The language I'm working on supports many ways of introducing symbols to the scope (such as declaring named functions, function parameters, let bindings, try-catch, patterns, ...). The default scope provider works fine for most of them, but I needed to write a custom scope provider since not all of them were detected by the default implementation.
Now, I would like to display a warning whenever a variable (or parameter, ...) name shadows an existing symbol. What is the simplest way to detect whenever any symbol declaration shadows a previous declaration?

[msujew]

Hey @aabounegm,

Let's say you have some sort of AST structure like this:

{
  a,
  b,
  c
  // New subblock
  {
    b // <-- generate error marker here, because it shadows the previous b
  }
}

You can then simply traverse the tree, and use a map on each level (filled with the names of variables on that level) and descent into the tree carrying the maps of previous levels along. If a variable is encountered that already is in one of the maps, generate an error.

Theoretically, if your ScopeComputation is set up this way, the data structure generated in there should be capable of providing all the information, as it already generates these maps to do the lexical scoping. However, this can lead to unexpected regressions in the shadowing validation if you decide to change the ScopeComputation to adjust the scoping logic.

[aabounegm]

Hi @msujew, thanks for the response.
Yes indeed, that's how scoping works in my language (basically JavaScript-like scoping).
I was hoping there would be an easy and generic (language-agnostic) way to mark variable shadowing using the current scoping service. Feels like it should be possible :)
But as I understand, there is currently no way around traversing the whole AST manually, so I guess that's what I will do. Thanks for the pointers.