// statistically we'll be on an IdentifierReference more often than on a Declaration:
            var selected = selection.Value.Selection;
            var qualified = selection.Value.QualifiedName;
            var match = _referencesBySelection
                .Where(kvp => kvp.Key.QualifiedName.Equals(qualified)
                              && kvp.Key.Selection.ContainsFirstCharacter(selected))
                .Select(kvp => kvp.Value)
                .OrderByDescending(declaration => declaration.DeclarationType)

        // statistically we'll be on an IdentifierReference more often than on a Declaration:
        var matches = _referencesBySelection
            .Where(kvp => kvp.Key.QualifiedName.Equals(selection.Value.QualifiedName)
                && kvp.Key.Selection.ContainsFirstCharacter(selection.Value.Selection))
            .SelectMany(kvp => kvp.Value)
            .OrderByDescending(reference => reference.Declaration.DeclarationType)
            .Select(reference => reference.Declaration)
            .Distinct();

    private readonly IDictionary<QualifiedSelection, IEnumerable<IdentifierReference>> _referencesBySelection;

        _declarationsBySelection = declarations.Where(declaration => !declaration.IsBuiltIn)
            .ToDictionary(declaration => declaration.QualifiedSelection, declaration => declaration);
        _referencesBySelection = declarations
            .SelectMany(declaration => declaration.References)
            .GroupBy(reference => new QualifiedSelection(reference.QualifiedModuleName, reference.Selection))
            .ToDictionary(group => group.Key, group => group.AsEnumerable());

    private readonly IDictionary<QualifiedSelection, IEnumerable<Declaration>> _declarationsBySelection;
    private readonly IDictionary<QualifiedSelection, IEnumerable<IdentifierReference>> _referencesBySelection;

        _declarationsBySelection = declarations.Where(declaration => !declaration.IsBuiltIn)
            .GroupBy(declaration => declaration.QualifiedSelection)
            .ToDictionary(group => group.Key, group => group.AsEnumerable());
        _referencesBySelection = declarations
            .SelectMany(declaration => declaration.References)
            .GroupBy(reference => new QualifiedSelection(reference.QualifiedModuleName, reference.Selection))
            .ToDictionary(group => group.Key, group => group.AsEnumerable());

    return other.Selection.Equals(_selection) &&
           other.QualifiedName.Equals(_qualifiedName);

    var other = obj as QualifiedSelection;
    if (other == null) { return false; }

    public override bool Equals(object obj)
    {
        if (obj is QualifiedSelection)
        {
            return Equals((QualifiedSelection) obj);
        }
        return false;
    }

    public bool Equals(QualifiedSelection other)
    {
        return other.Selection.Equals(_selection) && other.QualifiedName.Equals(_qualifiedName);
    }

    public Declaration FindSelectedDeclaration(ICodePane activeCodePane, bool procedureLevelOnly = false)
    {
        return DeclarationFinder.FindSelectedDeclaration(activeCodePane);
    }

var vbe = builder.BuildFromSingleStandardModule(inputCode, **out var component**, selection);

var mockHost = new Mock<IHostApplication>();
mockHost.SetupAllProperties();

        [TestMethod]
        public void AmbiguousNameSelectsSmallestScopedDeclaration()
        {
            var code = @"
Option Explicit

Public Sub foo()
    Dim foo As Long
    foo = 42
    Debug.Print foo
End Sub
";
            var vbe = new MockVbeBuilder()
                .ProjectBuilder("foo", ProjectProtection.Unprotected)
                .AddComponent("foo", ComponentType.StandardModule, code, new Selection(6, 19, 6, 19))
                .MockVbeBuilder()
                .Build();

            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object));

The following errors were reported during push:
	refs/heads/next, protected branch hook declined

        [TestMethod]
        public void AmbiguousNameSelectsSmallestScopedDeclaration()
        {
            var code = @"
Option Explicit

Public Sub foo()
    Dim foo As Long
    foo = 42
    Debug.Print foo
End Sub
";
            var vbe = new MockVbeBuilder()
                .ProjectBuilder("TestProject", ProjectProtection.Unprotected)
                .AddComponent("TestModule", ComponentType.StandardModule, code, new Selection(5, 5, 5, 5))
                .MockVbeBuilder()
                .Build();

IVBComponent component;
ICodeModule module;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, out module, selection);

var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component, out var module, selection);

    public Selection(int line, int column) : this(line, column, line, column) { }

var builder = new MockVbeBuilder();
IVBComponent component;
var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection);
var module = component.CodeModule;

IVBComponent component;
ICodeModule module;
var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out component, out module, selection);

public ICommandBar this[object index]
{
    get { return new CommandBar(IsWrappingNullReference ? null : Target[index]); }
}

Option Explicit

Enum Fizz
  Buzz = 4
End Enum

Sub test()
  Fizz Buzz
End Sub

Public Sub Fizz(Optional Fizz As Fizz = Buzz)
  Dim Buzz As Fizz
  Debug.Print Fizz, Buzz, [Fizz], [Buzz], [Buzz!Buzz], [Fizz!Buzz], VBAProject.Buzz.Fizz
End Sub

Option Explicit

Public Property Get Fizz()
  Fizz = 6
End Property

Dim bar As New Object '<-- Expected identifier.

  Dim o As VBAProject.Object
  Set o = New VBAProject.Object

'Class Object
Public Sub Report()
    Debug.Print "Ola!"
End Sub

'Module
Public Sub Foo()
    Object.Report
End Sub

'Class Object
Implements IDispatch

Public Sub Report()
    Debug.Print "Ola!"
End Sub

Public Sub IUnknown_Release()
    'Nah, don't think so.
End Sub

Implements IFoo

Public Sub IFoo_Release()   '<-- compile error "Function or interface marked as restricted."
    'Nah, don't think so.
End Sub