Reordering method parameters

Question

Next release of Rubberduck (should be 1.4) introduces a reorder parameters refactoring, which lets user reorder the parameters of a module (or class) member, and automatically adjust all usages.

Before:

DoSomething(ByVal a As String, ByVal b As Integer, ByVal c As Long)

After:

DoSomething(ByVal c As Long, ByVal b As Integer, ByVal a As String)

This is the IDialogView interface implementation:

interface IReorderParametersView : IDialogView
{
    Declaration Target { get; set; }
    List<Parameter> Parameters { get; set; }
    void InitializeParameterGrid();
}

And here is the Parameter class:

public class Parameter
{
    public string FullDeclaration { get; private set; }
    public int Index { get; private set; }
    public bool IsOptional { get; private set; }
    public bool IsParamArray { get; private set; }

    public Parameter(string fullDeclaration, int index)
    {
        FullDeclaration = fullDeclaration;
        Index = index;
        IsOptional = FullDeclaration.Contains("Optional");
        IsParamArray = FullDeclaration.Contains("ParamArray");
    }
}

This is the dialog code-behind:

public partial class ReorderParametersDialog : Form, IReorderParametersView
{
    public List<Parameter> Parameters { get; set; }
    private Parameter _selectedItem;
    private Rectangle _dragBoxFromMouseDown;
    Point _startPoint;
    private int _newRowIndex;

    public ReorderParametersDialog()
    {
        Parameters = new List<Parameter>();
        InitializeComponent();
        InitializeCaptions();

        MethodParametersGrid.SelectionChanged += MethodParametersGrid_SelectionChanged;
        MethodParametersGrid.MouseMove += MethodParametersGrid_MouseMove;
        MethodParametersGrid.MouseDown += MethodParametersGrid_MouseDown;
        MethodParametersGrid.DragOver += MethodParametersGrid_DragOver;
        MethodParametersGrid.DragDrop += MethodParametersGrid_DragDrop;
    }

    private void InitializeCaptions()
    {
        OkButton.Text = RubberduckUI.OkButtonText;
        CancelButton.Text = RubberduckUI.CancelButtonText;
        Text = RubberduckUI.ReorderParamsDialog_Caption;
        TitleLabel.Text = RubberduckUI.ReorderParamsDialog_TitleText;
        InstructionsLabel.Text = RubberduckUI.ReorderParamsDialog_InstructionsLabelText;
        MoveUpButton.Text = RubberduckUI.ReorderParamsDialog_MoveUpButtonText;
        MoveDownButton.Text = RubberduckUI.ReorderParamsDialog_MoveDownButtonText;
    }

    private void MethodParametersGrid_SelectionChanged(object sender, EventArgs e)
    {
        SelectionChanged();
    }

    private void MethodParametersGrid_MouseMove(object sender, MouseEventArgs e)
    {
        if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
        {
            if (_dragBoxFromMouseDown != Rectangle.Empty && !_dragBoxFromMouseDown.Contains(e.X, e.Y))
            {
                var dropEffect = MethodParametersGrid.DoDragDrop(
                      MethodParametersGrid.Rows[_newRowIndex],
                      DragDropEffects.Move);
            }
        }
    }

    private void MethodParametersGrid_MouseDown(object sender, MouseEventArgs e)
    {
        _newRowIndex = MethodParametersGrid.HitTest(e.X, e.Y).RowIndex;

        if (_newRowIndex == -1)
        {
            _dragBoxFromMouseDown = Rectangle.Empty;
            return;
        }

        _startPoint = new Point(e.X, e.Y);

        var dragSize = SystemInformation.DragSize;
        _dragBoxFromMouseDown = new Rectangle(new Point(e.X - (dragSize.Width / 2), e.Y - (dragSize.Height / 2)), dragSize);
    }

    private void MethodParametersGrid_DragOver(object sender, DragEventArgs e)
    {
        e.Effect = DragDropEffects.Move;
    }

    private void MethodParametersGrid_DragDrop(object sender, DragEventArgs e)
    {
        var clientPoint = MethodParametersGrid.PointToClient(new Point(e.X, e.Y));

        if (e.Effect == DragDropEffects.Move && _newRowIndex != -1)
        {
            var rowIndexOfItemUnderMouse = MethodParametersGrid.HitTest(clientPoint.X, clientPoint.Y).RowIndex;

            if (rowIndexOfItemUnderMouse < 0)
            {
                if (clientPoint.Y < _startPoint.Y)
                {
                    rowIndexOfItemUnderMouse = 0;
                }
                else
                {
                    rowIndexOfItemUnderMouse = Parameters.Count - 1;
                }
            }

            var tmp = Parameters.ElementAt(_newRowIndex);
            Parameters.RemoveAt(_newRowIndex);
            Parameters.Insert(rowIndexOfItemUnderMouse, tmp);
            ReselectParameter();
        }
    }

    public void InitializeParameterGrid()
    {
        MethodParametersGrid.AutoGenerateColumns = false;
        MethodParametersGrid.Columns.Clear();
        MethodParametersGrid.DataSource = Parameters;
        MethodParametersGrid.AlternatingRowsDefaultCellStyle.BackColor = Color.Lavender;
        MethodParametersGrid.MultiSelect = false;
        MethodParametersGrid.AllowUserToResizeRows = false;
        MethodParametersGrid.AllowDrop = true;
        MethodParametersGrid.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing;

        var column = new DataGridViewTextBoxColumn
        {
            Name = "Parameter",
            DataPropertyName = "FullDeclaration",
            HeaderText = "Parameter",
            ReadOnly = true,
            AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill
        };

        MethodParametersGrid.Columns.Add(column);
        _selectedItem = Parameters[0];
    }

    private void OkButtonClick(object sender, EventArgs e)
    {
        OnOkButtonClicked();
    }

    public event EventHandler CancelButtonClicked;
    public void OnCancelButtonClicked()
    {
        Hide();
    }

    public event EventHandler OkButtonClicked;
    public void OnOkButtonClicked()
    {
        var handler = OkButtonClicked;
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    private Declaration _target;
    public Declaration Target
    {
        get { return _target; }
        set { _target = value; }
    }

    private void MoveUpButtonClicked(object sender, EventArgs e)
    {
        if (MethodParametersGrid.SelectedRows.Count == 0)
        {
            return;
        }

        var selectedIndex = MethodParametersGrid.SelectedRows[0].Index;
        SwapParameters(selectedIndex, selectedIndex - 1);

        ReselectParameter();
    }

    private void MoveDownButtonClicked(object sender, EventArgs e)
    {
        if (MethodParametersGrid.SelectedRows.Count == 0)
        {
            return;
        }

        var selectedIndex = MethodParametersGrid.SelectedRows[0].Index;
        SwapParameters(selectedIndex, selectedIndex + 1);

        ReselectParameter();
    }

    private void SwapParameters(int index1, int index2)
    {
        var tmp = Parameters[index1];
        Parameters[index1] = Parameters[index2];
        Parameters[index2] = tmp;
    }

    private void ReselectParameter()
    {
        MethodParametersGrid.Refresh();
        MethodParametersGrid.Rows
                            .Cast<DataGridViewRow>()
                            .Single(row => row.DataBoundItem == _selectedItem).Selected = true;

        SelectionChanged();
    }

    private void SelectionChanged()
    {
        _selectedItem = MethodParametersGrid.SelectedRows.Count == 0
            ? null
            : (Parameter)MethodParametersGrid.SelectedRows[0].DataBoundItem;

        MoveUpButton.Enabled = _selectedItem != null
            && MethodParametersGrid.SelectedRows[0].Index != 0;

        MoveDownButton.Enabled = _selectedItem != null
            && MethodParametersGrid.SelectedRows[0].Index != Parameters.Count - 1;
    }
}

And here is the presenter:

class ReorderParametersPresenter
{
    private readonly IReorderParametersView _view;
    private readonly Declarations _declarations;
    private readonly QualifiedSelection _selection;

    public ReorderParametersPresenter(IReorderParametersView view, VBProjectParseResult parseResult, QualifiedSelection selection)
    {
        _view = view;
        _declarations = parseResult.Declarations;
        _selection = selection;

        _view.OkButtonClicked += OnOkButtonClicked;
    }

    public void Show()
    {
        AcquireTarget(_selection);

        if (_view.Target != null)
        {
            LoadParameters();

            if (_view.Parameters.Count < 2) 
            {
                var message = string.Format(RubberduckUI.ReorderPresenter_LessThanTwoVariablesError, _view.Target.IdentifierName);
                MessageBox.Show(message, RubberduckUI.ReorderParamsDialog_TitleText, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return; 
            }

            _view.InitializeParameterGrid();
           _view.ShowDialog();
        }
    }

    private void LoadParameters()
    {
        var procedure = (dynamic)_view.Target.Context;
        var argList = (VBAParser.ArgListContext)procedure.argList();
        var args = argList.arg();

        var index = 0;
        foreach (var arg in args)
        {
            _view.Parameters.Add(new Parameter(arg.GetText(), index++));
        }
    }

    private void OnOkButtonClicked(object sender, EventArgs e)
    {
        if (!_view.Parameters.Where((t, i) => t.Index != i).Any())
        {
            return;
        }

        var indexOfFirstOptionalParam = _view.Parameters.FindIndex(param => param.IsOptional);
        if (indexOfFirstOptionalParam >= 0)
        {
            for (var index = indexOfFirstOptionalParam + 1; index < _view.Parameters.Count; index++)
            {
                if (!_view.Parameters.ElementAt(index).IsOptional)
                {
                    MessageBox.Show(RubberduckUI.ReorderPresenter_OptionalVariableError, RubberduckUI.ReorderParamsDialog_TitleText, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
            }
        }

        var indexOfParamArray = _view.Parameters.FindIndex(param => param.IsParamArray);
        if (indexOfParamArray >= 0)
        {
            if (indexOfParamArray != _view.Parameters.Count - 1)
            {
                MessageBox.Show(RubberduckUI.ReorderPresenter_ParamArrayError, RubberduckUI.ReorderParamsDialog_TitleText, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
        }

        AdjustSignatures();
        AdjustReferences(_view.Target.References);
    }

    private void AdjustReferences(IEnumerable<IdentifierReference> references)
    {
        foreach (var reference in references.Where(item => item.Context != _view.Target.Context))
        {
            var proc = (dynamic)reference.Context.Parent;
            var module = reference.QualifiedModuleName.Component.CodeModule;

            // This is to prevent throws when this statement fails:
            // (VBAParser.ArgsCallContext)proc.argsCall();
            try
            {
                var check = (VBAParser.ArgsCallContext)proc.argsCall();
            }
            catch
            {
                continue;
            }

            var argList = (VBAParser.ArgsCallContext)proc.argsCall();

            if (argList == null)
            {
                continue;
            }

            RewriteCall(reference, argList, module);
        }
    }

    private void RewriteCall(IdentifierReference reference, VBAParser.ArgsCallContext argList, Microsoft.Vbe.Interop.CodeModule module)
    {
        var paramNames = argList.argCall().Select(arg => arg.GetText()).ToList();

        var lineCount = argList.Stop.Line - argList.Start.Line + 1; // adjust for total line count

        var variableIndex = 0;
        for (var line = argList.Start.Line; line < argList.Start.Line + lineCount; line++)
        {
            var newContent = module.Lines[line, 1].Replace(" , ", "");

            var currentStringIndex = line == argList.Start.Line ? reference.Declaration.IdentifierName.Length : 0;

            for (var i = 0; i < paramNames.Count && variableIndex < _view.Parameters.Count; i++)
            {
                var variableStringIndex = newContent.IndexOf(paramNames.ElementAt(i), currentStringIndex);

                if (variableStringIndex > -1)
                {
                    if (_view.Parameters.ElementAt(variableIndex).Index >= paramNames.Count)
                    {
                        newContent = newContent.Insert(variableStringIndex, " , ");
                        i--;
                        variableIndex++;
                        continue;
                    }

                    var oldVariableString = paramNames.ElementAt(i);
                    var newVariableString = paramNames.ElementAt(_view.Parameters.ElementAt(variableIndex).Index);
                    var beginningSub = newContent.Substring(0, variableStringIndex);
                    var replaceSub = newContent.Substring(variableStringIndex).Replace(oldVariableString, newVariableString);

                    newContent = beginningSub + replaceSub;

                    variableIndex++;
                    currentStringIndex = beginningSub.Length + newVariableString.Length;
                }
            }

            module.ReplaceLine(line, newContent);
        }
    }

    private void AdjustSignatures()
    {
        var proc = (dynamic)_view.Target.Context;
        var argList = (VBAParser.ArgListContext)proc.argList();
        var module = _view.Target.QualifiedName.QualifiedModuleName.Component.CodeModule;

        // if we are reordering a property getter, check if we need to reorder a letter/setter too
        if (_view.Target.DeclarationType == DeclarationType.PropertyGet)
        {
            var setter = _declarations.Items.FirstOrDefault(item => item.ParentScope == _view.Target.ParentScope &&
                                          item.IdentifierName == _view.Target.IdentifierName &&
                                          item.DeclarationType == DeclarationType.PropertySet);

            if (setter != null)
            {
                AdjustSignatures(setter);
            }

            var letter = _declarations.Items.FirstOrDefault(item => item.ParentScope == _view.Target.ParentScope &&
                          item.IdentifierName == _view.Target.IdentifierName &&
                          item.DeclarationType == DeclarationType.PropertyLet);

            if (letter != null)
            {
                AdjustSignatures(letter);
            }
        }

        RewriteSignature(argList, module);

        foreach (var withEvents in _declarations.Items.Where(item => item.IsWithEvents && item.AsTypeName == _view.Target.ComponentName))
        {
            foreach (var reference in _declarations.FindEventProcedures(withEvents))
            {
                AdjustSignatures(reference);
            }
        }

        var interfaceImplementations = _declarations.FindInterfaceImplementationMembers()
                                                    .Where(item => item.Project.Equals(_view.Target.Project) &&
                                                           item.IdentifierName == _view.Target.ComponentName + "_" + _view.Target.IdentifierName);
        foreach (var interfaceImplentation in interfaceImplementations)
        {
            AdjustSignatures(interfaceImplentation);

            AdjustReferences(interfaceImplentation.References);
        }
    }

    private void AdjustSignatures(IdentifierReference reference)
    {
        var proc = (dynamic)reference.Context.Parent;
        var module = reference.QualifiedModuleName.Component.CodeModule;
        var argList = (VBAParser.ArgListContext)proc.argList();

        RewriteSignature(argList, module);
    }

    private void AdjustSignatures(Declaration reference)
    {
        var proc = (dynamic)reference.Context.Parent;
        var module = reference.QualifiedName.QualifiedModuleName.Component.CodeModule;
        VBAParser.ArgListContext argList;

        if (reference.DeclarationType == DeclarationType.PropertySet || reference.DeclarationType == DeclarationType.PropertyLet)
        {
            argList = (VBAParser.ArgListContext)proc.children[0].argList();
        }
        else
        {
            argList = (VBAParser.ArgListContext)proc.subStmt().argList();
        }

        RewriteSignature(argList, module);
    }

    private void RewriteSignature(VBAParser.ArgListContext argList, Microsoft.Vbe.Interop.CodeModule module)
    {
        var args = argList.arg();

        var variableIndex = 0;
        for (var lineNum = argList.Start.Line; lineNum < argList.Start.Line + argList.GetSelection().LineCount; lineNum++)
        {
            var newContent = module.Lines[lineNum, 1];
            var currentStringIndex = 0;

            for (var i = variableIndex; i < _view.Parameters.Count; i++)
            {
                var variableStringIndex = newContent.IndexOf(_view.Parameters.Find(item => item.Index == variableIndex).FullDeclaration, currentStringIndex);

                if (variableStringIndex > -1)
                {
                    var oldVariableString = _view.Parameters.Find(item => item.Index == variableIndex).FullDeclaration;
                    var newVariableString = _view.Parameters.ElementAt(i).FullDeclaration;
                    var beginningSub = newContent.Substring(0, variableStringIndex);
                    var replaceSub = newContent.Substring(variableStringIndex).Replace(oldVariableString, newVariableString);

                    newContent = beginningSub + replaceSub;

                    variableIndex++;
                    currentStringIndex = beginningSub.Length + newVariableString.Length;
                }
            }

            module.ReplaceLine(lineNum, newContent);
        }
    }

    private static readonly DeclarationType[] ValidDeclarationTypes =
        {
             DeclarationType.Event,
             DeclarationType.Function,
             DeclarationType.Procedure,
             DeclarationType.PropertyGet,
             DeclarationType.PropertyLet,
             DeclarationType.PropertySet
        };

    private void AcquireTarget(QualifiedSelection selection)
    {
        var target = _declarations.Items
            .Where(item => !item.IsBuiltIn)
            .FirstOrDefault(item => IsSelectedDeclaration(selection, item)
                                 || IsSelectedReference(selection, item));

        if (target == null || !ValidDeclarationTypes.Contains(target.DeclarationType))
        {
            FindTarget(ref target, selection);
        }

        if (target != null && target.DeclarationType == DeclarationType.PropertySet)
        {
            var getter = _declarations.Items.FirstOrDefault(item => item.ParentScope == target.ParentScope &&
                                          item.IdentifierName == target.IdentifierName &&
                                          item.DeclarationType == DeclarationType.PropertyGet);

            if (getter != null)
            {
                target = getter;
            }
        }

        PromptIfTargetImplementsInterface(ref target);
        _view.Target = target;
    }

    private void FindTarget(ref Declaration target, QualifiedSelection selection)
    {
        var targets = _declarations.Items
            .Where(item => !item.IsBuiltIn
                        && item.ComponentName == selection.QualifiedName.ComponentName
                        && ValidDeclarationTypes.Contains(item.DeclarationType));

        foreach (var declaration in targets)
        {
            var startLine = declaration.Context.GetSelection().StartLine;
            var startColumn = declaration.Context.GetSelection().StartColumn;
            var endLine = declaration.Context.GetSelection().EndLine;
            var endColumn = declaration.Context.GetSelection().EndColumn;

            if (startLine <= selection.Selection.StartLine && endLine >= selection.Selection.EndLine)
            {
                if (startLine == selection.Selection.StartLine && startColumn > selection.Selection.StartColumn)
                {
                    continue;
                }
                if (endLine == selection.Selection.EndLine && endColumn < selection.Selection.EndColumn)
                {
                    continue;
                }

                target = declaration;
            }

            foreach (var reference in declaration.References)
            {
                var proc = (dynamic)reference.Context.Parent;

                // This is to prevent throws when this statement fails:
                // (VBAParser.ArgsCallContext)proc.argsCall();
                try
                {
                    var check = (VBAParser.ArgsCallContext)proc.argsCall();
                }
                catch
                {
                    continue;
                }

                var argList = (VBAParser.ArgsCallContext)proc.argsCall();

                if (argList == null)
                {
                    continue;
                }

                startLine = argList.Start.Line;
                startColumn = argList.Start.Column;
                endLine = argList.Stop.Line;
                endColumn = argList.Stop.Column + argList.Stop.Text.Length + 1;

                if ((startLine <= selection.Selection.StartLine && endLine >= selection.Selection.EndLine) && 
                    (startLine == selection.Selection.StartLine && startColumn > selection.Selection.StartColumn ||
                        endLine == selection.Selection.EndLine && endColumn < selection.Selection.EndColumn))
                {
                    continue;
                }

                target = reference.Declaration;
                return;
            }
        }
    }

    private void PromptIfTargetImplementsInterface(ref Declaration target)
    {
        var declaration = target;
        var interfaceImplementation = _declarations.FindInterfaceImplementationMembers().SingleOrDefault(m => m.Equals(declaration));
        if (target == null || interfaceImplementation == null)
        {
            return;
        }

        var interfaceMember = _declarations.FindInterfaceMember(interfaceImplementation);
        var message = string.Format(RubberduckUI.ReorderPresenter_TargetIsInterfaceMemberImplementation, target.IdentifierName, interfaceMember.ComponentName, interfaceMember.IdentifierName);

        var confirm = MessageBox.Show(message, RubberduckUI.ReorderParamsDialog_TitleText, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
        if (confirm == DialogResult.No)
        {
            target = null;
            return;
        }

        target = interfaceMember;
    }

    private bool IsSelectedReference(QualifiedSelection selection, Declaration declaration)
    {
        return declaration.References.Any(r =>
            r.QualifiedModuleName == selection.QualifiedName &&
            r.Selection.ContainsFirstCharacter(selection.Selection));
    }

    private bool IsSelectedDeclaration(QualifiedSelection selection, Declaration declaration)
    {
        return declaration.QualifiedName.QualifiedModuleName == selection.QualifiedName
               && (declaration.Selection.ContainsFirstCharacter(selection.Selection));
    }
}

My main concerns are how similar certain sections of the code are, any ideas to make this less repetitive are welcome.

Mathieu Guindon · Accepted Answer · 2015-05-20 14:29:31Z

In the Show() method, this condition could be reversed into a positive one:

if (_view.Target != null)
{
    ...
}

...which would reduce nesting because if the _view.Target is null, then there's nothing to act upon and the method can return early:

if (_view.Target == null)
{
    return;
}

The name of the resource string RubberduckUI.ReorderPresenter_LessThanTwoVariablesError is slightly off - a better name would be ReorderPresenter_LessThanTwoParametersError, or perhaps ReorderPresenter_RequiresTwoOrMoreParametersError.

There's a similar scheme with ReorderPresenter_OptionalVariableError: a "variable" isn't a "parameter", and the resource string could have a name that better explains why this is happening - like ReorderPresenter_OptionalParametersMustBeLastError.

I don't like that you're referring to parameters as "variables" in multiple places; there's a DeclarationType.Variable enum member, and then there's a DeclarationType.Parameter enum member - they are two completely distinct things.

From a UX standpoint, there's an opportunity here: a Parameter knows when it's Optional, so you have a way to validate the data before the user hits the Ok button. One way to implement this could be to remove the column heading, and insert a column before the "Parameters" column, that would display some [x] icon (Rubberduck uses such an icon elsewhere for similar purposes) with a tooltip explaining what's wrong; the Ok button could be disabled when an icon is shown in that column.

This would greatly simplify the OnOkButtonClicked handler, which has a confusing name (I've been guilty of that too) - OnXxxx should be for procedures that raise an event, not handle it.

Why is AdjustSignatures plural? It's only ever processing one signature at a time, right?

A Declaration called reference is confusing:

private void AdjustSignatures(Declaration reference)

Either you have a Declaration, or you have one of its references!

RubberDuck · Accepted Answer · 2015-05-20 14:38:05Z

Looks fairly clean to me for the most part.

You could reduce nesting a bit here by extracting a boolean method in the code behind.

private void MethodParametersGrid_MouseMove(object sender, MouseEventArgs e)
{
    if (ShouldDragDrop(e, _dragBoxFromMouseDown))
    {
        var dropEffect = MethodParametersGrid.DoDragDrop(
              MethodParametersGrid.Rows[_newRowIndex],
              DragDropEffects.Move);
    }
}

This also looks like a good opportunity to extract a method for clarity's sake.

_dragBoxFromMouseDown = new Rectangle(new Point(e.X - (dragSize.Width / 2), e.Y - (dragSize.Height / 2)), dragSize);

Remember, removing duplication isn't the only reason to create a method. It's also used to provide useful abstractions.

In MoveUpButtonClicked and MoveDownButtonClicked this line of code is duplicated.

var selectedIndex = MethodParametersGrid.SelectedRows[0].Index;

It might be worth extracting another method for it.

user34073user34073 · Accepted Answer · 2015-06-03 21:54:06Z

The FindTarget() method, which I believe has some bugs in this version, is very messy:

private void FindTarget(ref Declaration target, QualifiedSelection selection)
{
    var targets = _declarations.Items
        .Where(item => !item.IsBuiltIn
                    && item.ComponentName == selection.QualifiedName.ComponentName
                    && ValidDeclarationTypes.Contains(item.DeclarationType));

    foreach (var declaration in targets)
    {
        var startLine = declaration.Context.GetSelection().StartLine;
        var startColumn = declaration.Context.GetSelection().StartColumn;
        var endLine = declaration.Context.GetSelection().EndLine;
        var endColumn = declaration.Context.GetSelection().EndColumn;

        if (startLine <= selection.Selection.StartLine && endLine >= selection.Selection.EndLine)
        {
            if (startLine == selection.Selection.StartLine && startColumn > selection.Selection.StartColumn)
            {
                continue;
            }
            if (endLine == selection.Selection.EndLine && endColumn < selection.Selection.EndColumn)
            {
                continue;
            }

            target = declaration;
        }

        foreach (var reference in declaration.References)
        {
            var proc = (dynamic)reference.Context.Parent;

            // This is to prevent throws when this statement fails:
            // (VBAParser.ArgsCallContext)proc.argsCall();
            try
            {
                var check = (VBAParser.ArgsCallContext)proc.argsCall();
            }
            catch
            {
                continue;
            }

            var argList = (VBAParser.ArgsCallContext)proc.argsCall();

            if (argList == null)
            {
                continue;
            }

            startLine = argList.Start.Line;
            startColumn = argList.Start.Column;
            endLine = argList.Stop.Line;
            endColumn = argList.Stop.Column + argList.Stop.Text.Length + 1;

            if ((startLine <= selection.Selection.StartLine && endLine >= selection.Selection.EndLine) && 
                (startLine == selection.Selection.StartLine && startColumn > selection.Selection.StartColumn ||
                    endLine == selection.Selection.EndLine && endColumn < selection.Selection.EndColumn))
            {
                continue;
            }

            target = reference.Declaration;
            return;
        }
    }
}

I can clean this up by using the defined type Selection():

private Declaration FindTarget(QualifiedSelection selection, DeclarationType[] validDeclarationTypes)
{
    var target = _declarations.Items
        .Where(item => !item.IsBuiltIn)
        .FirstOrDefault(item => IsSelectedDeclaration(selection, item)
                             || IsSelectedReference(selection, item));

    if (target != null && validDeclarationTypes.Contains(target.DeclarationType))
    {
        return target;
    }

    target = null;

    var targets = _declarations.Items
        .Where(item => !item.IsBuiltIn
                    && item.ComponentName == selection.QualifiedName.ComponentName
                    && validDeclarationTypes.Contains(item.DeclarationType));

    var currentSelection = new Selection(0, 0, int.MaxValue, int.MaxValue);

    foreach (var declaration in targets)
    {
        var declarationSelection = new Selection(declaration.Context.Start.Line,
                                                 declaration.Context.Start.Column,
                                                 declaration.Context.Stop.Line,
                                                 declaration.Context.Stop.Column);

        if (currentSelection.Contains(declarationSelection) && declarationSelection.Contains(selection.Selection))
        {
            target = declaration;
            currentSelection = declarationSelection;
        }

        foreach (var reference in declaration.References)
        {
            var proc = (dynamic)reference.Context.Parent;
            VBAParser.ArgsCallContext paramList;

            // This is to prevent throws when this statement fails:
            // (VBAParser.ArgsCallContext)proc.argsCall();
            try
            {
                paramList = (VBAParser.ArgsCallContext)proc.argsCall();
            }
            catch
            {
                continue;
            }

            if (paramList == null) { continue; }

            var referenceSelection = new Selection(paramList.Start.Line,
                                                   paramList.Start.Column,
                                                   paramList.Stop.Line,
                                                   paramList.Stop.Column + paramList.Stop.Text.Length + 1);

            if (currentSelection.Contains(declarationSelection) && referenceSelection.Contains(selection.Selection))
            {
                target = reference.Declaration;
                currentSelection = referenceSelection;
            }
        }
    }
    return target;
}

In addition, I have made it much more generic, and it returns a value instead of modifying one.

Stack Exchange Network

Reordering method parameters

3 Answers 3

Your Answer

Linked

Hot Network Questions

Reordering method parameters

3 Answers 3

Your Answer

Sign up or log in

Post as a guest

Linked

Related

Hot Network Questions