Please revert the changes to the other lines here

So with this strategy, we collect all the hashtable ASTs that contain the token offset, and then try to find the smallest one. That works, but I think a better strategy is to:

• Find the smallest AST that contains the token offset
• Test whether that AST is a HashtableAst (since the = in HashtableAst key-value pairs is directly subordinate to that AST)

That way there's no need to sift through multiple ASTs reflecting on them to work out whether they're HashtableAsts, only the one containing the = operator.

One way to find the smallest containing AST is to do as you've done with the FindAll() method and sift through the returned ASTs looking for the one with the smallest extent. A slightly more efficient way is to implement a visitor like the one in PowerShell/vscode-powershell#2860 (comment).

Given its general name, this visitor should probably have overrides for all AST types so that it will reliably work for all position visits. The alternative is to implement this class as a private nested class for the relevant rule.

Fully intend to implement all overrides. Just didn't want to produce that much code before I knew I was barking up the right tree. It flummoxed me a bit when I first decided to work on this that there is no good way to search a PowerShell AST based on script position without writing 200+ lines of code. That is why I had tried the simpler solution first (that I agree with you was not ideal by a long shot).

Well there is another way, which is to use FindAll() instead:

IEnumerable<Ast> astsContainingToken = scriptAst.FindAll(foundAst => ContainsTokenExtent(token, foundAst), /* search through nested ASTs -- I can't remember the correct parameter name */ true);

// Find the containing AST with the smallest extent
Ast smallestContainingAst = astsContainingToken.First();
foreach (Ast containingAst in astsContainingToken)
{
    if (HasSmallerExtent(smallestContainingAst, containingAst))
    {
        smallestContainingAst = containingAst;
    }
}

Naturally you'd need to write the methods I've used there, but they basically contain logic you've already written

I did try something like that but ran into a problem because apparently Ast's can contain another of exactly the same size so there isn't always a smallest. At that point I figured as many issues as I have run into so far trying to use FindAll(), it would be better just to go the visitor route.