diff --git a/README.md b/README.md index c78720d738..0f24fad321 100644 --- a/README.md +++ b/README.md @@ -81,6 +81,14 @@ LibGit2Sharp is the library that has allowed us to integrate Git right into the Which basically means it's a reimplementation of Git in C. It also [happens to be the technology Microsoft uses for their own Git integration with Visual Studio](http://www.hanselman.com/blog/GitSupportForVisualStudioGitTFSAndVSPutIntoContext.aspx). +###[AvalonEdit](http://avalonedit.net) + +Source code looks a lot better with syntax highlighting, and AvalonEdit excels at it. + +> AvalonEdit is a WPF-based text editor component. It was written by [Daniel Grunwald](https://github.com/dgrunwald) for the [SharpDevelop](http://www.icsharpcode.net/OpenSource/SD/) IDE. Starting with version 5.0, AvalonEdit is released under the [MIT license](http://opensource.org/licenses/MIT). + +We're currently only using a tiny bit of this code editor's functionality (more to come!). + ###[WPF Localization Using RESX Files](http://www.codeproject.com/Articles/35159/WPF-Localization-Using-RESX-Files) This library makes localizing WPF applications at runtime using resx files a breeze. Thank you [Grant Frisken](http://www.codeproject.com/script/Membership/View.aspx?mid=1079060)! diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs index b0727aba9f..b2bda609fe 100644 --- a/RetailCoder.VBE/App.cs +++ b/RetailCoder.VBE/App.cs @@ -13,8 +13,10 @@ using System.Globalization; using System.Linq; using System.Windows.Forms; +using Rubberduck.UI.Command; using Rubberduck.UI.Command.MenuItems.CommandBars; using Rubberduck.VBEditor.SafeComWrappers.Abstract; +using Rubberduck.VersionCheck; namespace Rubberduck { @@ -28,6 +30,8 @@ public sealed class App : IDisposable private readonly IAppMenu _appMenus; private readonly RubberduckCommandBar _stateBar; private readonly IRubberduckHooks _hooks; + private readonly IVersionCheck _version; + private readonly CommandBase _checkVersionCommand; private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); @@ -39,7 +43,9 @@ public App(IVBE vbe, IGeneralConfigService configService, IAppMenu appMenus, RubberduckCommandBar stateBar, - IRubberduckHooks hooks) + IRubberduckHooks hooks, + IVersionCheck version, + CommandBase checkVersionCommand) { _vbe = vbe; _messageBox = messageBox; @@ -49,6 +55,8 @@ public App(IVBE vbe, _appMenus = appMenus; _stateBar = stateBar; _hooks = hooks; + _version = version; + _checkVersionCommand = checkVersionCommand; _hooks.MessageReceived += _hooks_MessageReceived; _configService.SettingsChanged += _configService_SettingsChanged; @@ -158,6 +166,11 @@ public void Startup() _stateBar.SetStatusLabelCaption(ParserState.Pending); _stateBar.EvaluateCanExecute(_parser.State); UpdateLoggingLevel(); + + if (_config.UserSettings.GeneralSettings.CheckVersion) + { + _checkVersionCommand.Execute(null); + } } public void Shutdown() @@ -229,8 +242,8 @@ private void CheckForLegacyIndenterSettings() private void LogRubberduckSart() { - var version = GetType().Assembly.GetName().Version.ToString(); - GlobalDiagnosticsContext.Set("RubberduckVersion", version); + var version = _version.CurrentVersion; + GlobalDiagnosticsContext.Set("RubberduckVersion", version.ToString()); var headers = new List { string.Format("Rubberduck version {0} loading:", version), diff --git a/RetailCoder.VBE/Common/StringExtensions.cs b/RetailCoder.VBE/Common/StringExtensions.cs index 9a1477060f..bce8384f60 100644 --- a/RetailCoder.VBE/Common/StringExtensions.cs +++ b/RetailCoder.VBE/Common/StringExtensions.cs @@ -15,5 +15,13 @@ public static string Captialize(this string input) tokens[0] = CultureInfo.CurrentUICulture.TextInfo.ToTitleCase(tokens[0]); return string.Join(" ", tokens); } + public static string CapitalizeFirstLetter(this string input) + { + if (input.Length == 0) + { + return string.Empty; + } + return input.Captialize().Substring(0, 1) + input.Substring(1); + } } } diff --git a/RetailCoder.VBE/Common/WinAPI/RawInput.cs b/RetailCoder.VBE/Common/WinAPI/RawInput.cs index ba9be9805a..014aab4585 100644 --- a/RetailCoder.VBE/Common/WinAPI/RawInput.cs +++ b/RetailCoder.VBE/Common/WinAPI/RawInput.cs @@ -3,19 +3,19 @@ using System.Collections.Generic; using System.ComponentModel; using System.Runtime.InteropServices; -using System.Windows.Forms; +using Rubberduck.UI; namespace Rubberduck.Common.WinAPI { - public class RawInput : NativeWindow + public class RawInput : SubclassingWindow { static readonly Guid DeviceInterfaceHid = new Guid("4D1E55B2-F16F-11CF-88CB-001111000030"); private readonly List _devices; private static readonly Logger Logger = LogManager.GetCurrentClassLogger(); + private static int _currentId; - public RawInput(IntPtr parentHandle) + public RawInput(IntPtr parentHandle) : base (new IntPtr((int)parentHandle + (_currentId++)), parentHandle) { - AssignHandle(parentHandle); _devices = new List(); } @@ -26,56 +26,56 @@ public void AddDevice(IRawDevice device) public IRawDevice CreateKeyboard() { - return new RawKeyboard(Handle, true); + return new RawKeyboard(Hwnd, true); } public IRawDevice CreateMouse() { - return new RawMouse(Handle, true); - } + return new RawMouse(Hwnd, true); + } - protected override void WndProc(ref Message message) + public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData) { - switch ((WM)message.Msg) + switch ((WM)msg) { case WM.INPUT: - { - if (message.LParam == IntPtr.Zero) - { - break; - } - InputData rawBuffer; - var dwSize = 0; - var res = User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, IntPtr.Zero, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader))); - if (res != 0) { - var ex = new Win32Exception(Marshal.GetLastWin32Error()); - Logger.Error(ex, "Error sizing the rawinput buffer: {0}", ex.Message); - break; - } + if (lParam == IntPtr.Zero) + { + break; + } + InputData rawBuffer; + var dwSize = 0; + var res = User32.GetRawInputData(lParam, DataCommand.RID_INPUT, IntPtr.Zero, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader))); + if (res != 0) + { + var ex = new Win32Exception(Marshal.GetLastWin32Error()); + Logger.Error(ex, "Error sizing the rawinput buffer: {0}", ex.Message); + break; + } - res = User32.GetRawInputData(message.LParam, DataCommand.RID_INPUT, out rawBuffer, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader))); - if (res == -1) - { - var ex = new Win32Exception(Marshal.GetLastWin32Error()); - Logger.Error(ex, "Error getting the rawinput buffer: {0}", ex.Message); - break; - } - if (res == dwSize) - { - foreach (var device in _devices) + res = User32.GetRawInputData(lParam, DataCommand.RID_INPUT, out rawBuffer, ref dwSize, Marshal.SizeOf(typeof(RawInputHeader))); + if (res == -1) { - device.ProcessRawInput(rawBuffer); + var ex = new Win32Exception(Marshal.GetLastWin32Error()); + Logger.Error(ex, "Error getting the rawinput buffer: {0}", ex.Message); + break; + } + if (res == dwSize) + { + foreach (var device in _devices) + { + device.ProcessRawInput(rawBuffer); + } + } + else + { + //Something is seriously f'd up with Windows - the number of bytes copied does not match the reported buffer size. } } - else - { - //Something is seriously f'd up with Windows - the number of bytes copied does not match the reported buffer size. - } - } - break; + break; } - base.WndProc(ref message); + return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData); } } } diff --git a/RetailCoder.VBE/Extension.cs b/RetailCoder.VBE/Extension.cs index ea6bd2ee0b..9b5b2e3c26 100644 --- a/RetailCoder.VBE/Extension.cs +++ b/RetailCoder.VBE/Extension.cs @@ -172,6 +172,7 @@ private void InitializeAddIn() { splash = new Splash { + // note: IVersionCheck.CurrentVersion could return this string. Version = string.Format("version {0}", Assembly.GetExecutingAssembly().GetName().Version) }; splash.Show(); diff --git a/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs b/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs index cb444e79e4..ea592123cf 100644 --- a/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs +++ b/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs @@ -3,6 +3,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Resources; using Rubberduck.Inspections.Results; +using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -20,29 +21,13 @@ public ObjectVariableNotSetInspection(RubberduckParserState state) public override string Description { get { return InspectionsUI.ObjectVariableNotSetInspectionName; } } public override CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } } - private static readonly IReadOnlyList ValueTypes = new[] - { - Tokens.Boolean, - Tokens.Byte, - Tokens.Currency, - Tokens.Date, - Tokens.Decimal, - Tokens.Double, - Tokens.Integer, - Tokens.Long, - Tokens.LongLong, - Tokens.Single, - Tokens.String, - Tokens.Variant - }; - public override IEnumerable GetInspectionResults() { var interestingDeclarations = State.AllUserDeclarations.Where(item => !item.IsSelfAssigned && !item.IsArray && - !ValueTypes.Contains(item.AsTypeName) && + !SymbolList.ValueTypes.Contains(item.AsTypeName) && (item.AsTypeDeclaration == null || (!ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration) && item.AsTypeDeclaration.DeclarationType != DeclarationType.Enumeration && item.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)) && @@ -54,7 +39,7 @@ public override IEnumerable GetInspectionResults() (item.DeclarationType == DeclarationType.Function || item.DeclarationType == DeclarationType.PropertyGet) && !item.IsArray && item.IsTypeSpecified - && !ValueTypes.Contains(item.AsTypeName) + && !SymbolList.ValueTypes.Contains(item.AsTypeName) && (item.AsTypeDeclaration == null // null if unresolved (e.g. in unit tests) || (item.AsTypeDeclaration.DeclarationType != DeclarationType.Enumeration && item.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType && item.AsTypeDeclaration != null diff --git a/RetailCoder.VBE/Inspections/QuickFixes/AssignedByValParameterQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/AssignedByValParameterQuickFix.cs new file mode 100644 index 0000000000..20a5deafd1 --- /dev/null +++ b/RetailCoder.VBE/Inspections/QuickFixes/AssignedByValParameterQuickFix.cs @@ -0,0 +1,172 @@ +using Rubberduck.Inspections.Abstract; +using System; +using System.Collections.Generic; +using System.Linq; +using Rubberduck.Parsing; +using Rubberduck.VBEditor; +using Rubberduck.Inspections.Resources; +using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Symbols; +using System.Windows.Forms; +using Rubberduck.UI.Refactorings; +using Rubberduck.Common; + +namespace Rubberduck.Inspections.QuickFixes +{ + public class AssignedByValParameterQuickFix : QuickFixBase + { + private readonly Declaration _target; + private string _localCopyVariableName; + private bool _forceUseOfSuggestedName; + private readonly string[] _originalCodeLines; + + public AssignedByValParameterQuickFix(Declaration target, QualifiedSelection selection) + : base(target.Context, selection, InspectionsUI.AssignedByValParameterQuickFix) + { + _target = target; + _forceUseOfSuggestedName = false; + _localCopyVariableName = string.Empty; + + _originalCodeLines = GetMethodLines(); + } + + public override bool CanFixInModule { get { return false; } } + public override bool CanFixInProject { get { return false; } } + + //This function exists solely to support unit testing - by preventing the popup dialog + public void TESTONLY_FixUsingAutoGeneratedName() + { + _forceUseOfSuggestedName = true; + Fix(); + } + + public override void Fix() + { + if (_forceUseOfSuggestedName) + { + _localCopyVariableName = AutoSuggestedName(); + IsCancelled = false; + } + else + { + GetLocalCopyVariableNameFromUser(); + } + + if (!IsCancelled) + { + ModifyBlockToUseLocalCopyVariable(); + } + } + + private void GetLocalCopyVariableNameFromUser() + { + using (var view = new AssignedByValParameterQuickFixDialog(_originalCodeLines)) + { + view.Target = _target; + view.NewName = AutoSuggestedName(); + view.ShowDialog(); + + IsCancelled = view.DialogResult == DialogResult.Cancel; + if (!IsCancelled) { _localCopyVariableName = view.NewName; } + } + } + + private void ModifyBlockToUseLocalCopyVariable() + { + if(ProposedNameIsInUse()) { return; } + + var module = Selection.QualifiedName.Component.CodeModule; + var startLine = Selection.Selection.StartLine; + + module.InsertLines(++startLine, BuildLocalCopyDeclaration()); + module.InsertLines(++startLine, BuildLocalCopyAssignment()); + var moduleLines = GetModuleLines(); + //moduleLines array index is zero-based + var endOfScopeStatement = GetEndOfScopeStatementForDeclaration(moduleLines[Selection.Selection.StartLine - 1]); + + var isInScope = true; + int zbIndex; //Zero-Based index for moduleLines array + //starts with lines after the above inserts + for (zbIndex = startLine ; isInScope && zbIndex < module.CountOfLines; zbIndex++) + { + var obIndex = zbIndex + 1; //One-Based index for module object + if (LineRequiresUpdate(moduleLines[zbIndex])) + { + var newStatement = moduleLines[zbIndex].Replace(_target.IdentifierName, _localCopyVariableName); + module.ReplaceLine(obIndex, newStatement); + } + isInScope = !moduleLines[zbIndex].Contains(endOfScopeStatement); + } + } + + private bool ProposedNameIsInUse() + { + return GetMethodLines().Any(c => c.Contains(Tokens.Dim + " " + _localCopyVariableName + " ")); + } + + private bool LineRequiresUpdate(string line) + { + return line.Contains(" " + _target.IdentifierName + " ") + || line.Contains(NameAsLeftHandSide()) + || line.Contains(NameAsRightHandSide()) + || line.Contains(NameAsObjectMethodOrAccessorCall()) + || line.Contains(NameAsSubOrFunctionParam()) + || line.Contains(NameAsSubOrFunctionParamFirst()) + || line.Contains(NameAsSubOrFunctionParamLast()); + } + + private string NameAsLeftHandSide() { return _target.IdentifierName + " "; } + private string NameAsRightHandSide() { return " " + _target.IdentifierName; } + private string NameAsObjectMethodOrAccessorCall() { return " " + _target.IdentifierName + "."; } + private string NameAsSubOrFunctionParam() { return _target.IdentifierName + ","; } + private string NameAsSubOrFunctionParamFirst() { return "(" + _target.IdentifierName; } + private string NameAsSubOrFunctionParamLast() { return _target.IdentifierName + ")"; } + + private string BuildLocalCopyDeclaration() + { + return Tokens.Dim + " " + _localCopyVariableName + " " + Tokens.As + + " " + _target.AsTypeName; + } + + private string BuildLocalCopyAssignment() + { + return (SymbolList.ValueTypes.Contains(_target.AsTypeName) ? string.Empty : Tokens.Set + " ") + + _localCopyVariableName + " = " + _target.IdentifierName; + } + + private string[] GetModuleLines() + { + var module = Selection.QualifiedName.Component.CodeModule; + var lines = module.GetLines(1, module.CountOfLines); + string[] newLine = { "\r\n" }; + return lines.Split(newLine, StringSplitOptions.None); + } + + private string[] GetMethodLines() + { + var zbIndex = Selection.Selection.StartLine - 1; + var allLines = GetModuleLines(); + + var endStatement = GetEndOfScopeStatementForDeclaration(allLines[zbIndex]); + + var isInScope = true; + var codeBlockLines = new List(); + for ( ; isInScope && zbIndex < allLines.Count(); zbIndex++) + { + codeBlockLines.Add(allLines[zbIndex]); + isInScope = !allLines[zbIndex].Contains(endStatement); + } + return codeBlockLines.ToArray(); + } + + private string GetEndOfScopeStatementForDeclaration(string declaration) + { + return declaration.Contains("Sub ") ? "End Sub" : "End Function"; + } + + private string AutoSuggestedName() + { + return "local" + _target.IdentifierName.CapitalizeFirstLetter(); + } + } +} diff --git a/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs index f0893b2271..344221bdfd 100644 --- a/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs +++ b/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs @@ -2,6 +2,7 @@ using Antlr4.Runtime; using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.Resources; +using Rubberduck.Parsing; using Rubberduck.Parsing.Grammar; using Rubberduck.Parsing.Symbols; using Rubberduck.VBEditor; @@ -47,7 +48,7 @@ private void FixTypeHintUsage(string hint, ICodeModule module, Selection selecti { var line = module.GetLines(selection.StartLine, 1); - var asTypeClause = ' ' + Tokens.As + ' ' + Declaration.TypeHintToTypeName[hint]; + var asTypeClause = ' ' + Tokens.As + ' ' + SymbolList.TypeHintToTypeName[hint]; string fix; diff --git a/RetailCoder.VBE/Inspections/Resources/InspectionsUI.Designer.cs b/RetailCoder.VBE/Inspections/Resources/InspectionsUI.Designer.cs index 74022f361a..4cd311f879 100644 --- a/RetailCoder.VBE/Inspections/Resources/InspectionsUI.Designer.cs +++ b/RetailCoder.VBE/Inspections/Resources/InspectionsUI.Designer.cs @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // // This code was generated by a tool. -// Runtime Version:4.0.30319.36373 +// Runtime Version:4.0.30319.42000 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. @@ -132,6 +132,15 @@ public static string AssignedByValParameterInspectionResultFormat { } } + /// + /// Looks up a localized string similar to Create and use a local copy of the parameter. + /// + public static string AssignedByValParameterQuickFix { + get { + return ResourceManager.GetString("AssignedByValParameterQuickFix", resourceCulture); + } + } + /// /// Looks up a localized string similar to Replace 'Dim' with 'Private'. /// diff --git a/RetailCoder.VBE/Inspections/Resources/InspectionsUI.resx b/RetailCoder.VBE/Inspections/Resources/InspectionsUI.resx index c2997ce134..b80a481b47 100644 --- a/RetailCoder.VBE/Inspections/Resources/InspectionsUI.resx +++ b/RetailCoder.VBE/Inspections/Resources/InspectionsUI.resx @@ -647,4 +647,7 @@ If the parameter can be null, ignore this inspection result; passing a null valu Use Application.WorksheetFunction explicitly. + + Create and use a local copy of the parameter + \ No newline at end of file diff --git a/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs b/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs index 98e7c426b6..d622bec60e 100644 --- a/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/Results/AssignedByValParameterInspectionResult.cs @@ -27,6 +27,7 @@ public override IEnumerable QuickFixes { return _quickFixes ?? (_quickFixes = new QuickFixBase[] { + new AssignedByValParameterQuickFix(Target, QualifiedSelection), new PassParameterByReferenceQuickFix(Target.Context, QualifiedSelection), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName) }); diff --git a/RetailCoder.VBE/Inspections/Results/ImplicitActiveWorkbookReferenceInspectionResult.cs b/RetailCoder.VBE/Inspections/Results/ImplicitActiveWorkbookReferenceInspectionResult.cs index 093bd53de2..43f91bb8c8 100644 --- a/RetailCoder.VBE/Inspections/Results/ImplicitActiveWorkbookReferenceInspectionResult.cs +++ b/RetailCoder.VBE/Inspections/Results/ImplicitActiveWorkbookReferenceInspectionResult.cs @@ -30,7 +30,7 @@ public override IEnumerable QuickFixes public override string Description { - get { return string.Format(InspectionsUI.ImplicitActiveSheetReferenceInspectionResultFormat, Context.GetText() /*_reference.Declaration.IdentifierName*/); } + get { return string.Format(InspectionsUI.ImplicitActiveWorkbookReferenceInspectionResultFormat, Context.GetText() /*_reference.Declaration.IdentifierName*/); } } } } \ No newline at end of file diff --git a/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs b/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs index 9e922c3b5d..ff9f94c71c 100644 --- a/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs +++ b/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs @@ -3,7 +3,7 @@ using Rubberduck.Inspections.Abstract; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Inspections.Resources; -using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing; using Rubberduck.Parsing.VBA; using Rubberduck.Parsing.Symbols; @@ -20,27 +20,12 @@ public SelfAssignedDeclarationInspection(RubberduckParserState state) public override string Description { get { return InspectionsUI.SelfAssignedDeclarationInspectionName; } } public override CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } } - private static readonly IReadOnlyList ValueTypes = new[] - { - Tokens.Boolean, - Tokens.Byte, - Tokens.Currency, - Tokens.Date, - Tokens.Decimal, - Tokens.Double, - Tokens.Integer, - Tokens.Long, - Tokens.LongLong, - Tokens.Single, - Tokens.String - }; - public override IEnumerable GetInspectionResults() { return UserDeclarations .Where(declaration => declaration.IsSelfAssigned && declaration.IsTypeSpecified - && !ValueTypes.Contains(declaration.AsTypeName) + && !SymbolList.ValueTypes.Contains(declaration.AsTypeName) && declaration.DeclarationType == DeclarationType.Variable && (declaration.AsTypeDeclaration == null || declaration.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType) diff --git a/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs b/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs index 8b5e74ba3f..60afec4dc8 100644 --- a/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs +++ b/RetailCoder.VBE/Inspections/UseMeaningfulNameInspection.cs @@ -60,23 +60,8 @@ public override IEnumerable GetInspectionResults() private static bool IsBadIdentifier(string identifier) { - return identifier.Length < 3 || - char.IsDigit(identifier.Last()) || - !HasVowels(identifier) || - NameIsASingleRepeatedLetter(identifier); - } - - private static bool HasVowels(string identifier) - { - const string vowels = "aeiouyàâäéèêëïîöôùûü"; - return identifier.Any(character => vowels.Any(vowel => - string.Compare(vowel.ToString(), character.ToString(), StringComparison.OrdinalIgnoreCase) == 0)); - } - private static bool NameIsASingleRepeatedLetter(string identifierName) - { - string firstLetter = identifierName.First().ToString(); - return identifierName.All(a => string.Compare(a.ToString(), firstLetter, - StringComparison.OrdinalIgnoreCase) == 0); + var validator = new VariableNameValidator(identifier); + return !validator.IsMeaningfulName(); } } } diff --git a/RetailCoder.VBE/Inspections/VariableNameValidator.cs b/RetailCoder.VBE/Inspections/VariableNameValidator.cs new file mode 100644 index 0000000000..d560adaa71 --- /dev/null +++ b/RetailCoder.VBE/Inspections/VariableNameValidator.cs @@ -0,0 +1,98 @@ +using System.Globalization; +using Rubberduck.Parsing.Grammar; +using System; +using System.Linq; + +namespace Rubberduck.Inspections +{ + public class VariableNameValidator + { + public VariableNameValidator() { } + public VariableNameValidator(string identifier) { _identifier = identifier; } + + private const string AllVowels = "aeiouyàâäéèêëïîöôùûü"; + private const int MinVariableNameLength = 3; + + /**** Meaningful Name Characteristics ************/ + public bool HasVowels + { + get + { + return _identifier.Any(character => AllVowels.Any(vowel => + string.Compare(vowel.ToString(CultureInfo.InvariantCulture), + character.ToString(CultureInfo.InvariantCulture), StringComparison.OrdinalIgnoreCase) == 0)); + } + } + + public bool HasConsonants + { + get + { + return !_identifier.All(character => AllVowels.Any(vowel => + string.Compare(vowel.ToString(CultureInfo.InvariantCulture), + character.ToString(CultureInfo.InvariantCulture), StringComparison.OrdinalIgnoreCase) == 0)); + } + } + + public bool IsSingleRepeatedLetter + { + get + { + var firstLetter = _identifier.First().ToString(CultureInfo.InvariantCulture); + return _identifier.All(a => string.Compare(a.ToString(CultureInfo.InvariantCulture), firstLetter, + StringComparison.OrdinalIgnoreCase) == 0); + } + } + + public bool IsTooShort { get { return _identifier.Length < MinVariableNameLength; } } + public bool EndsWithNumber { get { return char.IsDigit(_identifier.Last()); } } + + /**** Invalid Name Characteristics ************/ + public bool StartsWithNumber { get { return FirstLetterIsDigit(); } } + + public bool IsReservedName + { + get + { + var tokenValues = typeof(Tokens).GetFields().Select(item => item.GetValue(null)).Cast().Select(item => item); + return tokenValues.Contains(_identifier, StringComparer.InvariantCultureIgnoreCase); + } + } + + public bool ContainsSpecialCharacters { get { return UsesSpecialCharacters(); } } + + private string _identifier; + public string Identifier + { + get { return _identifier; } + set { _identifier = value; } + } + + public bool IsValidName() + { + return !string.IsNullOrEmpty(_identifier) + && !StartsWithNumber + && !IsReservedName + && !ContainsSpecialCharacters; + } + + public bool IsMeaningfulName() + { + return HasVowels + && HasConsonants + && !IsSingleRepeatedLetter + && !IsTooShort + && !EndsWithNumber; + } + + private bool FirstLetterIsDigit() + { + return !char.IsLetter(_identifier.FirstOrDefault()); + } + + private bool UsesSpecialCharacters() + { + return _identifier.Any(c => !char.IsLetterOrDigit(c) && c != '_'); + } + } +} diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs index 9055c65b31..fb63cd65d2 100644 --- a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs +++ b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs @@ -4,6 +4,7 @@ using System.Linq; using NLog; using Rubberduck.Navigation.Folders; +using Rubberduck.Parsing; using Rubberduck.Parsing.Annotations; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; @@ -201,7 +202,7 @@ public string PanelTitle } var typeName = declaration.HasTypeHint - ? Declaration.TypeHintToTypeName[declaration.TypeHint] + ? SymbolList.TypeHintToTypeName[declaration.TypeHint] : declaration.AsTypeName; return nameWithDeclarationType + ": " + typeName; diff --git a/RetailCoder.VBE/Navigation/Folders/FolderHelper.cs b/RetailCoder.VBE/Navigation/Folders/FolderHelper.cs index 41cb38c030..980559c95a 100644 --- a/RetailCoder.VBE/Navigation/Folders/FolderHelper.cs +++ b/RetailCoder.VBE/Navigation/Folders/FolderHelper.cs @@ -2,14 +2,12 @@ using Rubberduck.Navigation.CodeExplorer; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; -using Rubberduck.Settings; namespace Rubberduck.Navigation.Folders { public class FolderHelper { private readonly RubberduckParserState _state; - private readonly ConfigurationLoader _configLoader; private static readonly DeclarationType[] ComponentTypes = { @@ -19,10 +17,9 @@ public class FolderHelper DeclarationType.UserForm, }; - public FolderHelper(RubberduckParserState state, ConfigurationLoader configLoader) + public FolderHelper(RubberduckParserState state) { _state = state; - _configLoader = configLoader; } public CodeExplorerCustomFolderViewModel GetFolderTree(Declaration declaration = null) @@ -65,8 +62,7 @@ public CodeExplorerCustomFolderViewModel GetFolderTree(Declaration declaration = private char GetDelimiter() { - var settings = _configLoader.LoadConfiguration(); - return settings.UserSettings.GeneralSettings.Delimiter; + return '.'; } } } diff --git a/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs b/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs index d0e24e2bd2..9d6ffe4792 100644 --- a/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs +++ b/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs @@ -1,8 +1,6 @@ using System; -using System.Collections.Generic; using System.Linq; using System.Windows.Forms; -using Rubberduck.Parsing.Grammar; using Rubberduck.SmartIndenter; namespace Rubberduck.Refactorings.ExtractMethod @@ -59,21 +57,6 @@ private void PrepareView(IExtractMethodModel extractedMethodModel, IExtractMetho _view.OnRefreshPreview(); } - private static readonly IEnumerable ValueTypes = new[] - { - Tokens.Boolean, - Tokens.Byte, - Tokens.Currency, - Tokens.Date, - Tokens.Decimal, - Tokens.Double, - Tokens.Integer, - Tokens.Long, - Tokens.LongLong, - Tokens.Single, - Tokens.String - }; - private void GeneratePreview(IExtractMethodModel extractMethodModel,IExtractMethodProc extractMethodProc ) { extractMethodModel.Method.MethodName = _view.MethodName; diff --git a/RetailCoder.VBE/Root/RubberduckModule.cs b/RetailCoder.VBE/Root/RubberduckModule.cs index f2c24cf20c..7b2b42e51a 100644 --- a/RetailCoder.VBE/Root/RubberduckModule.cs +++ b/RetailCoder.VBE/Root/RubberduckModule.cs @@ -33,7 +33,6 @@ using Rubberduck.UI.CodeExplorer.Commands; using Rubberduck.UI.Command.MenuItems.CommandBars; using Rubberduck.VBEditor.Application; -using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using Rubberduck.VBEditor.SafeComWrappers.Office.Core.Abstract; using ReparseCommandMenuItem = Rubberduck.UI.Command.MenuItems.CommandBars.ReparseCommandMenuItem; @@ -62,7 +61,6 @@ public override void Load() // bind VBE and AddIn dependencies to host-provided instances. Bind().ToConstant(_vbe); Bind().ToConstant(_addin); - Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); Bind().ToSelf().InSingletonScope(); Bind().To(); @@ -70,6 +68,7 @@ public override void Load() Bind().ToSelf().InSingletonScope(); Bind().To().InSingletonScope(); + Bind().To().WhenInjectedExactlyInto(); BindCodeInspectionTypes(); var assemblies = new[] @@ -86,7 +85,6 @@ public override void Load() BindCommandsToMenuItems(); - Rebind().To().InSingletonScope(); Rebind().To().InSingletonScope(); Rebind().To(); Bind>().ToMethod(t => () => KernelInstance.Get().LoadConfiguration().UserSettings.IndenterSettings); diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj index 4603d3ece4..21c0b9aa32 100644 --- a/RetailCoder.VBE/Rubberduck.csproj +++ b/RetailCoder.VBE/Rubberduck.csproj @@ -232,6 +232,10 @@ True + + ..\packages\HtmlAgilityPack.1.4.9.5\lib\Net45\HtmlAgilityPack.dll + True + ..\packages\AvalonEdit.5.0.3\lib\Net40\ICSharpCode.AvalonEdit.dll @@ -281,6 +285,7 @@ + @@ -375,6 +380,7 @@ + True True @@ -437,6 +443,7 @@ + @@ -493,6 +500,8 @@ + + @@ -507,6 +516,7 @@ + LinkButton.xaml @@ -747,6 +757,12 @@ + + Form + + + AssignedByValParameterQuickFixDialog.cs + Form @@ -1091,6 +1107,9 @@ FindSymbolDialog.cs + + AssignedByValParameterQuickFixDialog.cs + EncapsulateFieldDialog.cs diff --git a/RetailCoder.VBE/Settings/GeneralSettings.cs b/RetailCoder.VBE/Settings/GeneralSettings.cs index 484169eded..440f3b9671 100644 --- a/RetailCoder.VBE/Settings/GeneralSettings.cs +++ b/RetailCoder.VBE/Settings/GeneralSettings.cs @@ -9,10 +9,11 @@ public interface IGeneralSettings { DisplayLanguageSetting Language { get; set; } bool ShowSplash { get; set; } + bool CheckVersion { get; set; } bool SmartIndenterPrompted { get; set; } bool AutoSaveEnabled { get; set; } int AutoSavePeriod { get; set; } - char Delimiter { get; set; } + //char Delimiter { get; set; } int MinimumLogLevel { get; set; } } @@ -21,10 +22,11 @@ public class GeneralSettings : IGeneralSettings, IEquatable { public DisplayLanguageSetting Language { get; set; } public bool ShowSplash { get; set; } + public bool CheckVersion { get; set; } public bool SmartIndenterPrompted { get; set; } public bool AutoSaveEnabled { get; set; } public int AutoSavePeriod { get; set; } - public char Delimiter { get; set; } + //public char Delimiter { get; set; } private int _logLevel; public int MinimumLogLevel @@ -51,10 +53,11 @@ public GeneralSettings() { Language = new DisplayLanguageSetting("en-US"); ShowSplash = true; + CheckVersion = true; SmartIndenterPrompted = false; AutoSaveEnabled = false; AutoSavePeriod = 10; - Delimiter = '.'; + //Delimiter = '.'; MinimumLogLevel = LogLevel.Off.Ordinal; } @@ -63,10 +66,11 @@ public bool Equals(GeneralSettings other) return other != null && Language.Equals(other.Language) && ShowSplash == other.ShowSplash && + CheckVersion == other.CheckVersion && SmartIndenterPrompted == other.SmartIndenterPrompted && AutoSaveEnabled == other.AutoSaveEnabled && AutoSavePeriod == other.AutoSavePeriod && - Delimiter.Equals(other.Delimiter) && + //Delimiter.Equals(other.Delimiter) && MinimumLogLevel == other.MinimumLogLevel; } } diff --git a/RetailCoder.VBE/UI/About/AboutControl.xaml b/RetailCoder.VBE/UI/About/AboutControl.xaml index dc335432ed..313f4c027d 100644 --- a/RetailCoder.VBE/UI/About/AboutControl.xaml +++ b/RetailCoder.VBE/UI/About/AboutControl.xaml @@ -65,19 +65,11 @@ FontWeight="SemiBold" FontSize="10" /> Code Review Stack Exchange -JetBrains ReSharper Community Team + xml:space="preserve">JetBrains ReSharper Community Team +Code Review Stack Exchange Stack Overflow - - - Michal Krzych (vba4all.com) -Knjname developer blog (clockahead.blogspot.jp) - - + @@ -86,7 +78,7 @@ Knjname developer blog (clockahead.blogspot.jp) Andrew Jackson Andrin Meier Bruno Costa -Carlos J. Quintero (MZ-Tools articles & help with VBE API) +Carlos J. Quintero (MZ-Tools) @Comintern @daFreeMan @Duga SE chat bot @@ -95,13 +87,14 @@ Frank Van Heeswijk Gareth Leachman @Heslacher Jeroen Vannevel +Michal Krzych (vba4all.com) @mjolka Philip Wales -Rob Bovey +Rob Bovey (Smart Indenter) Ross McLean Ross Knudsen Simon Forsberg -Stephen Bullen +Stephen Bullen (Smart Indenter) - + \ No newline at end of file diff --git a/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs b/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs index 76310003a1..3972a20637 100644 --- a/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs +++ b/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs @@ -1,4 +1,5 @@ using System.Linq; +using Rubberduck.Parsing; using Rubberduck.Parsing.Symbols; using Rubberduck.VBEditor.SafeComWrappers.Abstract; @@ -39,7 +40,7 @@ private string Format(Declaration declaration) var formattedDeclaration = string.Empty; var moduleName = declaration.QualifiedName.QualifiedModuleName; var typeName = declaration.HasTypeHint - ? Declaration.TypeHintToTypeName[declaration.TypeHint] + ? SymbolList.TypeHintToTypeName[declaration.TypeHint] : declaration.AsTypeName; var declarationType = RubberduckUI.ResourceManager.GetString("DeclarationType_" + declaration.DeclarationType, Settings.Settings.Culture); @@ -83,6 +84,12 @@ private string Format(Declaration declaration) declaration.IdentifierName, typeName); } + else if (declaration.DeclarationType == DeclarationType.ComAlias) + { + formattedDeclaration = string.Format("{0};{1}.{2} (alias:{3})", + System.IO.Path.GetFileName(moduleName.ProjectPath), moduleName.ProjectName, + declaration.IdentifierName, declaration.AsTypeName); + } var subscripts = declaration.IsArray ? "()" : string.Empty; if (declaration.ParentDeclaration != null && declaration.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Member)) diff --git a/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs index 4ecf12c26f..8dcdebdbae 100644 --- a/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs +++ b/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs @@ -1,5 +1,6 @@ using System.Linq; using System.Runtime.InteropServices; +using System.Windows.Forms; using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.Refactorings.Rename; @@ -53,22 +54,22 @@ private Declaration GetTarget() { var designer = ((dynamic)component.Target).Designer; - foreach (var control in designer.Controls) + if (designer.selected.count == 1) { - if (!control.InSelection) - { - Marshal.ReleaseComObject(control); - continue; - } - + var control = designer.selected.item(0); var result = _state.AllUserDeclarations .FirstOrDefault(item => item.DeclarationType == DeclarationType.Control && project.HelpFile == item.ProjectId && item.ComponentName == component.Name && item.IdentifierName == control.Name); + Marshal.ReleaseComObject(control); Marshal.ReleaseComObject(designer); return result; + } else { + var message = string.Format(RubberduckUI.RenameDialog_AmbiguousSelection); + _messageBox.Show(message, RubberduckUI.RenameDialog_Caption, MessageBoxButtons.OK, + MessageBoxIcon.Exclamation); } } } diff --git a/RetailCoder.VBE/UI/Command/ReparseCommand.cs b/RetailCoder.VBE/UI/Command/ReparseCommand.cs index 7e760503e2..344d82517e 100644 --- a/RetailCoder.VBE/UI/Command/ReparseCommand.cs +++ b/RetailCoder.VBE/UI/Command/ReparseCommand.cs @@ -33,7 +33,6 @@ protected override bool CanExecuteImpl(object parameter) protected override void ExecuteImpl(object parameter) { _state.OnParseRequested(this); - _state.StartEventSinks(); // no-op if already started } } } diff --git a/RetailCoder.VBE/UI/Command/VersionCheckCommand.cs b/RetailCoder.VBE/UI/Command/VersionCheckCommand.cs new file mode 100644 index 0000000000..42c388246b --- /dev/null +++ b/RetailCoder.VBE/UI/Command/VersionCheckCommand.cs @@ -0,0 +1,66 @@ +using System; +using System.Diagnostics; +using System.Windows.Forms; +using NLog; +using Rubberduck.VersionCheck; + +namespace Rubberduck.UI.Command +{ + public interface IExternalProcess + { + void Start(string fileName); + } + + public class ExternalProcess : IExternalProcess + { + public void Start(string fileName) + { + var info = new ProcessStartInfo(fileName) + { + WindowStyle = ProcessWindowStyle.Maximized + }; + Process.Start(info); + } + } + + public class VersionCheckCommand : CommandBase + { + private readonly IVersionCheck _versionCheck; + private readonly IMessageBox _prompt; + private readonly IExternalProcess _process; + + public VersionCheckCommand(IVersionCheck versionCheck, IMessageBox prompt, IExternalProcess process) + : base(LogManager.GetCurrentClassLogger()) + { + _versionCheck = versionCheck; + _prompt = prompt; + _process = process; + } + + protected override async void ExecuteImpl(object parameter) + { + Logger.Info("Executing version check."); + await _versionCheck + .GetLatestVersionAsync() + .ContinueWith(t => + { + if (_versionCheck.CurrentVersion < t.Result) + { + PromptAndBrowse(t.Result); + } + }); + } + + private void PromptAndBrowse(Version latestVersion) + { + var prompt = string.Format(RubberduckUI.VersionCheck_NewVersionAvailable, latestVersion); + if (_prompt.Show(prompt, RubberduckUI.Rubberduck, MessageBoxButtons.YesNo, MessageBoxIcon.Information) == + DialogResult.No) + { + return; + } + + _process.Start("https://github.com/rubberduck-vba/Rubberduck/releases/latest"); + } + } +} diff --git a/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs b/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs index ba7f1f7b3c..4264db2308 100644 --- a/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs +++ b/RetailCoder.VBE/UI/DockableToolwindowPresenter.cs @@ -1,5 +1,4 @@ using System; -using System.Configuration; using System.Runtime.InteropServices; using System.Windows.Forms; using NLog; @@ -59,17 +58,13 @@ private IWindow CreateToolWindow(IDockableUserControl control) } catch (COMException exception) { - //var logEvent = new LogEventInfo(LogLevel.Error, Logger.Name, "Error Creating Control"); - //logEvent.Exception = exception; - //logEvent.Properties.Add("EventID", 1); - Logger.Error(exception); - return null; //throw; + throw; } catch (NullReferenceException exception) { Logger.Error(exception); - return null; //throw; + throw; } var userControlHost = (_DockableWindowHost)_userControlObject; @@ -135,6 +130,16 @@ protected virtual void Dispose(bool disposing) } if (disposing && _window != null) { + if (_userControlObject != null) + { + ((_DockableWindowHost)_userControlObject).Dispose(); + } + _userControlObject = null; + + if (_userControl != null) + { + _userControl.Dispose(); + } // cleanup unmanaged resource wrappers _window.Close(); _window.Release(true); @@ -143,18 +148,6 @@ protected virtual void Dispose(bool disposing) { return; } - - if (_userControlObject != null) - { - ((_DockableWindowHost)_userControlObject).Dispose(); - } - _userControlObject = null; - - if (_userControl != null) - { - _userControl.Dispose(); - } - _disposed = true; } } diff --git a/RetailCoder.VBE/UI/DockableWindowHost.cs b/RetailCoder.VBE/UI/DockableWindowHost.cs index ddbe50e636..b2b5442331 100644 --- a/RetailCoder.VBE/UI/DockableWindowHost.cs +++ b/RetailCoder.VBE/UI/DockableWindowHost.cs @@ -1,6 +1,5 @@ using System; using System.ComponentModel; -using System.Diagnostics; using System.Drawing; using System.Runtime.InteropServices; using System.Windows.Forms; @@ -23,14 +22,27 @@ public partial class _DockableWindowHost : UserControl private const string ProgId = "Rubberduck.UI.DockableWindowHost"; public static string RegisteredProgId { get { return ProgId; } } + // ReSharper disable UnusedAutoPropertyAccessor.Local [StructLayout(LayoutKind.Sequential)] private struct Rect - { - public int Left { get; set; } + { + public int Left { get; set; } public int Top { get; set; } public int Right { get; set; } public int Bottom { get; set; } } + // ReSharper restore UnusedAutoPropertyAccessor.Local + + [StructLayout(LayoutKind.Explicit)] + private struct LParam + { + [FieldOffset(0)] + public uint Value; + [FieldOffset(0)] + public readonly ushort LowWord; + [FieldOffset(2)] + public readonly ushort HighWord; + } [DllImport("User32.dll")] static extern IntPtr GetParent(IntPtr hWnd); @@ -39,14 +51,20 @@ private struct Rect static extern int GetClientRect(IntPtr hWnd, ref Rect lpRect); private IntPtr _parentHandle; - private SubClassingWindow _subClassingWindow; + private ParentWindow _subClassingWindow; internal void AddUserControl(UserControl control, IntPtr vbeHwnd) { _parentHandle = GetParent(Handle); - _subClassingWindow = new SubClassingWindow(_parentHandle, vbeHwnd); + _subClassingWindow = new ParentWindow(vbeHwnd, new IntPtr(GetHashCode()), _parentHandle); _subClassingWindow.CallBackEvent += OnCallBackEvent; + //DO NOT REMOVE THIS CALL. Dockable windows are instantiated by the VBE, not directly by RD. On top of that, + //since we have to inherit from UserControl we don't have to keep handling window messages until the VBE gets + //around to destroying the control's host or it results in an access violation when the base class is disposed. + //We need to manually call base.Dispose() ONLY in response to a WM_DESTROY message. + GC.KeepAlive(this); + if (control != null) { control.Dock = DockStyle.Fill; @@ -57,7 +75,16 @@ internal void AddUserControl(UserControl control, IntPtr vbeHwnd) private void OnCallBackEvent(object sender, SubClassingWindowEventArgs e) { - AdjustSize(); + if (!e.Closing) + { + var param = new LParam {Value = (uint) e.LParam}; + Size = new Size(param.LowWord, param.HighWord); + } + else + { + _subClassingWindow.CallBackEvent -= OnCallBackEvent; + _subClassingWindow.Dispose(); + } } private void AdjustSize() @@ -111,8 +138,19 @@ protected override bool ProcessKeyPreview(ref Message m) return result; } + protected override void DefWndProc(ref Message m) + { + //See the comment in the ctor for why we have to listen for this. + if (m.Msg == (int) WM.DESTROY) + { + base.Dispose(true); + return; + } + base.DefWndProc(ref m); + } + [ComVisible(false)] - public class SubClassingWindow : NativeWindow + public class ParentWindow : SubclassingWindow { public event SubClassingWindowEventHandler CallBackEvent; public delegate void SubClassingWindowEventHandler(object sender, SubClassingWindowEventArgs e); @@ -121,46 +159,39 @@ public class SubClassingWindow : NativeWindow private void OnCallBackEvent(SubClassingWindowEventArgs e) { - Debug.Assert(CallBackEvent != null, "CallBackEvent != null"); - CallBackEvent(this, e); + if (CallBackEvent != null) + { + CallBackEvent(this, e); + } } - public SubClassingWindow(IntPtr handle, IntPtr vbeHwnd) + public ParentWindow(IntPtr vbeHwnd, IntPtr id, IntPtr handle) : base(id, handle) { _vbeHwnd = vbeHwnd; - AssignHandle(handle); } - protected override void WndProc(ref Message msg) + private bool _closing; + public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData) { - var closing = false; - switch ((uint)msg.Msg) + switch ((uint)msg) { case (uint)WM.SIZE: - var args = new SubClassingWindowEventArgs(msg); - OnCallBackEvent(args); + var args = new SubClassingWindowEventArgs(lParam); + if (!_closing) OnCallBackEvent(args); break; case (uint)WM.SETFOCUS: - User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Handle, Handle); + if (!_closing) User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Hwnd, Hwnd); break; case (uint)WM.KILLFOCUS: - User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Handle, IntPtr.Zero); + if (!_closing) User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Hwnd, IntPtr.Zero); break; case (uint)WM.RUBBERDUCK_SINKING: - closing = true; + OnCallBackEvent(new SubClassingWindowEventArgs(lParam) { Closing = true }); + _closing = true; break; } - base.WndProc(ref msg); - if (closing) - { - DestroyHandle(); - } + return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData); } - - //~SubClassingWindow() - //{ - // ReleaseHandle(); - //} } } } diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.Designer.cs b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.Designer.cs new file mode 100644 index 0000000000..9d6687461d --- /dev/null +++ b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.Designer.cs @@ -0,0 +1,214 @@ +namespace Rubberduck.UI.Refactorings +{ + partial class AssignedByValParameterQuickFixDialog + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(AssignedByValParameterQuickFixDialog)); + this.panel1 = new System.Windows.Forms.Panel(); + this.TitleLabel = new System.Windows.Forms.Label(); + this.InstructionsLabel = new System.Windows.Forms.Label(); + this.panel2 = new System.Windows.Forms.Panel(); + this.flowLayoutPanel2 = new System.Windows.Forms.FlowLayoutPanel(); + this.CancelDialogButton = new System.Windows.Forms.Button(); + this.OkButton = new System.Windows.Forms.Button(); + this.InvalidNameValidationIcon = new System.Windows.Forms.PictureBox(); + this.NewNameBox = new System.Windows.Forms.TextBox(); + this.NameLabel = new System.Windows.Forms.Label(); + this.FeedbackLabel = new System.Windows.Forms.Label(); + this.panel1.SuspendLayout(); + this.panel2.SuspendLayout(); + this.flowLayoutPanel2.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.InvalidNameValidationIcon)).BeginInit(); + this.SuspendLayout(); + // + // panel1 + // + this.panel1.BackColor = System.Drawing.Color.White; + this.panel1.Controls.Add(this.TitleLabel); + this.panel1.Controls.Add(this.InstructionsLabel); + this.panel1.Dock = System.Windows.Forms.DockStyle.Top; + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(773, 99); + this.panel1.TabIndex = 14; + // + // TitleLabel + // + this.TitleLabel.AutoSize = true; + this.TitleLabel.Font = new System.Drawing.Font("Microsoft Sans Serif", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.TitleLabel.Location = new System.Drawing.Point(18, 14); + this.TitleLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.TitleLabel.Name = "TitleLabel"; + this.TitleLabel.Padding = new System.Windows.Forms.Padding(3, 2, 3, 2); + this.TitleLabel.Size = new System.Drawing.Size(273, 26); + this.TitleLabel.TabIndex = 4; + this.TitleLabel.Text = "Specify Local Variable Name"; + // + // InstructionsLabel + // + this.InstructionsLabel.AutoSize = true; + this.InstructionsLabel.Location = new System.Drawing.Point(14, 46); + this.InstructionsLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.InstructionsLabel.Name = "InstructionsLabel"; + this.InstructionsLabel.Padding = new System.Windows.Forms.Padding(6); + this.InstructionsLabel.Size = new System.Drawing.Size(255, 32); + this.InstructionsLabel.TabIndex = 5; + this.InstructionsLabel.Text = "Please specify new name for \'{0}\'."; + // + // panel2 + // + this.panel2.BackColor = System.Drawing.SystemColors.ControlDark; + this.panel2.Controls.Add(this.flowLayoutPanel2); + this.panel2.Dock = System.Windows.Forms.DockStyle.Bottom; + this.panel2.Location = new System.Drawing.Point(0, 243); + this.panel2.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(773, 65); + this.panel2.TabIndex = 16; + // + // flowLayoutPanel2 + // + this.flowLayoutPanel2.BackColor = System.Drawing.SystemColors.ControlDark; + this.flowLayoutPanel2.Controls.Add(this.CancelDialogButton); + this.flowLayoutPanel2.Controls.Add(this.OkButton); + this.flowLayoutPanel2.Dock = System.Windows.Forms.DockStyle.Bottom; + this.flowLayoutPanel2.FlowDirection = System.Windows.Forms.FlowDirection.RightToLeft; + this.flowLayoutPanel2.Location = new System.Drawing.Point(0, -1); + this.flowLayoutPanel2.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.flowLayoutPanel2.Name = "flowLayoutPanel2"; + this.flowLayoutPanel2.Padding = new System.Windows.Forms.Padding(12, 12, 0, 12); + this.flowLayoutPanel2.Size = new System.Drawing.Size(773, 66); + this.flowLayoutPanel2.TabIndex = 2; + // + // CancelDialogButton + // + this.CancelDialogButton.BackColor = System.Drawing.SystemColors.ButtonFace; + this.CancelDialogButton.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.CancelDialogButton.Location = new System.Drawing.Point(645, 17); + this.CancelDialogButton.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.CancelDialogButton.Name = "CancelDialogButton"; + this.CancelDialogButton.Size = new System.Drawing.Size(112, 35); + this.CancelDialogButton.TabIndex = 2; + this.CancelDialogButton.Text = "Cancel"; + this.CancelDialogButton.UseVisualStyleBackColor = false; + // + // OkButton + // + this.OkButton.BackColor = System.Drawing.SystemColors.ButtonFace; + this.OkButton.DialogResult = System.Windows.Forms.DialogResult.OK; + this.OkButton.Location = new System.Drawing.Point(525, 17); + this.OkButton.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.OkButton.Name = "OkButton"; + this.OkButton.Size = new System.Drawing.Size(112, 35); + this.OkButton.TabIndex = 1; + this.OkButton.Text = "Ok"; + this.OkButton.UseVisualStyleBackColor = false; + // + // InvalidNameValidationIcon + // + this.InvalidNameValidationIcon.Image = global::Rubberduck.Properties.Resources.cross_circle; + this.InvalidNameValidationIcon.Location = new System.Drawing.Point(739, 108); + this.InvalidNameValidationIcon.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.InvalidNameValidationIcon.Name = "InvalidNameValidationIcon"; + this.InvalidNameValidationIcon.Size = new System.Drawing.Size(16, 16); + this.InvalidNameValidationIcon.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize; + this.InvalidNameValidationIcon.TabIndex = 18; + this.InvalidNameValidationIcon.TabStop = false; + // + // NewNameBox + // + this.NewNameBox.Location = new System.Drawing.Point(86, 121); + this.NewNameBox.Margin = new System.Windows.Forms.Padding(4, 5, 4, 5); + this.NewNameBox.Name = "NewNameBox"; + this.NewNameBox.Size = new System.Drawing.Size(666, 26); + this.NewNameBox.TabIndex = 15; + this.NewNameBox.WordWrap = false; + this.NewNameBox.TextChanged += new System.EventHandler(this.NewNameBox_TextChanged); + // + // NameLabel + // + this.NameLabel.AutoSize = true; + this.NameLabel.Location = new System.Drawing.Point(14, 126); + this.NameLabel.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.NameLabel.Name = "NameLabel"; + this.NameLabel.Size = new System.Drawing.Size(55, 20); + this.NameLabel.TabIndex = 17; + this.NameLabel.Text = "Name:"; + // + // FeedbackLabel + // + this.FeedbackLabel.Location = new System.Drawing.Point(86, 160); + this.FeedbackLabel.Name = "FeedbackLabel"; + this.FeedbackLabel.Size = new System.Drawing.Size(666, 61); + this.FeedbackLabel.TabIndex = 19; + this.FeedbackLabel.Text = "THis has text"; + // + // AssignedByValParameterQuickFixDialog + // + this.AutoScaleDimensions = new System.Drawing.SizeF(9F, 20F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(773, 308); + this.Controls.Add(this.FeedbackLabel); + this.Controls.Add(this.panel1); + this.Controls.Add(this.panel2); + this.Controls.Add(this.InvalidNameValidationIcon); + this.Controls.Add(this.NewNameBox); + this.Controls.Add(this.NameLabel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "AssignedByValParameterQuickFixDialog"; + this.ShowInTaskbar = false; + this.Text = "Rubberduck - Name Local Variable"; + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.panel2.ResumeLayout(false); + this.flowLayoutPanel2.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)(this.InvalidNameValidationIcon)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Label TitleLabel; + private System.Windows.Forms.Label InstructionsLabel; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel2; + private System.Windows.Forms.Button CancelDialogButton; + private System.Windows.Forms.Button OkButton; + private System.Windows.Forms.PictureBox InvalidNameValidationIcon; + private System.Windows.Forms.TextBox NewNameBox; + private System.Windows.Forms.Label NameLabel; + private System.Windows.Forms.Label FeedbackLabel; + } +} \ No newline at end of file diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.cs b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.cs new file mode 100644 index 0000000000..64d9d16110 --- /dev/null +++ b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.cs @@ -0,0 +1,134 @@ +using System; +using System.Linq; +using System.Windows.Forms; +using Rubberduck.Parsing.Grammar; +using Rubberduck.Parsing.Symbols; +using Rubberduck.Inspections; + +namespace Rubberduck.UI.Refactorings +{ + public partial class AssignedByValParameterQuickFixDialog : Form, IDialogView + { + private readonly string[] _moduleLines; + private bool _userInputIsValid; + + public AssignedByValParameterQuickFixDialog(string[] moduleLines) + { + _moduleLines = moduleLines; + _userInputIsValid = false; + InitializeComponent(); + InitializeCaptions(); + } + + private void InitializeCaptions() + { + Text = RubberduckUI.AssignedByValParamQFixDialog_Caption; + OkButton.Text = RubberduckUI.OK; + CancelDialogButton.Text = RubberduckUI.CancelButtonText; + TitleLabel.Text = RubberduckUI.AssignedByValParamQFixDialog_TitleText; + InstructionsLabel.Text = RubberduckUI.AssignedByValParamQFixDialog_InstructionsLabelText; + NameLabel.Text = RubberduckUI.NameLabelText; + } + + private void NewNameBox_TextChanged(object sender, EventArgs e) + { + NewName = NewNameBox.Text; + } + + private Declaration _target; + public Declaration Target + { + get { return _target; } + set + { + _target = value; + if (_target == null) + { + return; + } + + var declarationType = + RubberduckUI.ResourceManager.GetString("DeclarationType_" + _target.DeclarationType, Settings.Settings.Culture); + InstructionsLabel.Text = string.Format(RubberduckUI.AssignedByValParamQFixDialog_InstructionsLabelText, declarationType, + _target.IdentifierName); + } + } + + public string NewName + { + get { return NewNameBox.Text; } + set + { + NewNameBox.Text = value; + FeedbackLabel.Text = !value.Equals(string.Empty) ? GetVariableNameFeedback() : string.Empty; + SetControlsProperties(); + } + } + + private string GetVariableNameFeedback() + { + var validator = new VariableNameValidator(NewName); + _userInputIsValid = validator.IsValidName(); + + if (UserInputIsBlank()) + { + return string.Empty; + } + if (validator.StartsWithNumber) + { + return RubberduckUI.AssignedByValDialog_DoesNotStartWithLetter; + } + if (validator.ContainsSpecialCharacters) + { + return RubberduckUI.AssignedByValDialog_InvalidCharacters; + } + if (validator.IsReservedName) + { + return string.Format(RubberduckUI.AssignedByValDialog_ReservedKeywordFormat, NewName); + } + if (NewNameAlreadyUsed()) + { + return string.Format(RubberduckUI.AssignedByValDialog_NewNameAlreadyUsedFormat, NewName); + } + if (IsByValIdentifier()) + { + return string.Format(RubberduckUI.AssignedByValDialog_IsByValIdentifierFormat, NewName); + } + if (!validator.IsMeaningfulName()) + { + return string.Format(RubberduckUI.AssignedByValDialog_QuestionableEntryFormat, NewName); + } + return string.Empty; + } + + private void SetControlsProperties() + { + OkButton.Visible = _userInputIsValid; + OkButton.Enabled = _userInputIsValid; + InvalidNameValidationIcon.Visible = !_userInputIsValid; + } + + private bool UserInputIsBlank() + { + return NewName.Equals(string.Empty); + } + + private bool IsByValIdentifier() + { + return NewName.Equals(Target.IdentifierName,StringComparison.OrdinalIgnoreCase); + } + + private bool NewNameAlreadyUsed() + { + for(int idx = 0; idx < _moduleLines.Count();idx++) + { + string[] splitLine = _moduleLines[idx].ToUpper().Split(new[] { ' ', ',' }); + if( splitLine.Contains(Tokens.Dim.ToUpper()) && splitLine.Contains(NewName.ToUpper())) + { + return true; + } + } + return false; + } + } +} diff --git a/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.resx b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.resx new file mode 100644 index 0000000000..d3a1a2980d --- /dev/null +++ b/RetailCoder.VBE/UI/Refactorings/AssignedByValParameterQuickFixDialog.resx @@ -0,0 +1,142 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAEAEA4AAAEAIADgAwAAFgAAACgAAAAQAAAAHAAAAAEAIAAAAAAAuAMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAB4AAABxAAEBtQEYGOMCLCz3AzEx/AIhIewABwfFAAAAiQAAADYAAAABAAAAAAAA + AAAAAAAAAAAAAQAAAJIDODj5CJqa/wzh4f8O/f3/Dv///w7///8O////De/v/wq0tP8ES0v/AAAAewAA + AAAAAAAAAAAAAAAAAEcFWlr/Dv///w7///8O////Dv///w7///8O////Dv///w7///8O////Dvv7/wMw + MPkAAAAgAAAAAAAAAAAAAQGpC8zM/w7///8O////Dv///w7///8O////Dv///w7///8O////Dv///w7/ + //8JoKD/AAAAfAAAAAAAAAAAARMT4g78/P8O////Dv///w7///8O////Dv///w7///8O////Dv///w7/ + //8O////DNzc/wAAALAAAAAAAAAAAAImJvcO////Dv///w7///8O////Dv///w7///8O////Dv///w7/ + //8O////Dv///w3o6P8AAAC8AAAAAAAAAAACHh7vDv///w7///8O////Dv///w7///8O////Dv///w7/ + //8O////Dv///w7///8LxMT/AAAAngAAAAAAAAAAAAQExg3o6P8O////Dv///wmnp/8GZ2f/B3l5/wZ1 + df8Kr6//Dv///w7///8O////Bmxs/wAAAFIAAAAAAAAAAAAAAGwHgoL/Dv///wq+vv8BDAzTAAAAOQAA + AE8BDQ3yDNLS/w7///8O////Dv///wZlZf8AABS4AAAPgQAAAA0AAAAIAQwM1AVjY/8ABwfEAAAAGAAA + AAAAAABNBnJy/w7///8O////Dv///w7///8N5ub/AAM+/wAA4P8AAC62AAAAAAAAACAAAABLAAAAAgAA + AAAAAAAAAAAAaAiUlP8O////Dv///wvKyv8Lvr7/Dvv7/wEQMf8AAP//AACF/wAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAADkFV1f/Dv///w7///8HdHT/Blxc/wvMzP8AAAXWAAAoogAAF58AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAEBrwiQkP8O+/v/Dv///wzY2P8CLCz1AAAAMQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAACHARkZ4wIpKfQABga8AAAANgAAAAAAAAAAAAAAAMAH + AAAABwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAAAAAQAAACMAAAA/AAAAP4DAAD+BwAA + + + \ No newline at end of file diff --git a/RetailCoder.VBE/UI/RubberduckUI.Designer.cs b/RetailCoder.VBE/UI/RubberduckUI.Designer.cs index 04b4ec2212..4ea3778c4e 100644 --- a/RetailCoder.VBE/UI/RubberduckUI.Designer.cs +++ b/RetailCoder.VBE/UI/RubberduckUI.Designer.cs @@ -1,7 +1,7 @@ //------------------------------------------------------------------------------ // // This code was generated by a tool. -// Runtime Version:4.0.30319.36373 +// Runtime Version:4.0.30319.42000 // // Changes to this file may cause incorrect behavior and will be lost if // the code is regenerated. @@ -117,7 +117,7 @@ public static string AboutWindow_ContributorsHeader { } /// - /// Looks up a localized string similar to © Copyright 2014-2016 Mathieu Guindon & Christopher McClellan. + /// Looks up a localized string similar to © Copyright 2014-2017 Mathieu Guindon & Christopher McClellan. /// public static string AboutWindow_Copyright { get { @@ -190,6 +190,87 @@ public static string AllReferences_NoneFound { } } + /// + /// Looks up a localized string similar to Variable names must begin with a letter.. + /// + public static string AssignedByValDialog_DoesNotStartWithLetter { + get { + return ResourceManager.GetString("AssignedByValDialog_DoesNotStartWithLetter", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Variable names cannot contain special characters other than underscores.. + /// + public static string AssignedByValDialog_InvalidCharacters { + get { + return ResourceManager.GetString("AssignedByValDialog_InvalidCharacters", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The local variable cannot be the same as the '{0}' parameter it replaces. + /// + public static string AssignedByValDialog_IsByValIdentifierFormat { + get { + return ResourceManager.GetString("AssignedByValDialog_IsByValIdentifierFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to '{0}' is already used in this scope.. + /// + public static string AssignedByValDialog_NewNameAlreadyUsedFormat { + get { + return ResourceManager.GetString("AssignedByValDialog_NewNameAlreadyUsedFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The identifier '{0}' will trigger a "Use meaningful name" inspection result. Consider choosing a different name.. + /// + public static string AssignedByValDialog_QuestionableEntryFormat { + get { + return ResourceManager.GetString("AssignedByValDialog_QuestionableEntryFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to '{0}' is a reserved keyword.. + /// + public static string AssignedByValDialog_ReservedKeywordFormat { + get { + return ResourceManager.GetString("AssignedByValDialog_ReservedKeywordFormat", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Assigned ByVal parameter QuickFix - Make Local Copy. + /// + public static string AssignedByValParamQFixDialog_Caption { + get { + return ResourceManager.GetString("AssignedByValParamQFixDialog_Caption", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Please specify a name to use for the local copy of ByVal {0} '{1}'. + /// + public static string AssignedByValParamQFixDialog_InstructionsLabelText { + get { + return ResourceManager.GetString("AssignedByValParamQFixDialog_InstructionsLabelText", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Specify Local Copy Variable Name. + /// + public static string AssignedByValParamQFixDialog_TitleText { + get { + return ResourceManager.GetString("AssignedByValParamQFixDialog_TitleText", resourceCulture); + } + } + /// /// Looks up a localized string similar to Cancel. /// @@ -1470,6 +1551,15 @@ public static string GeneralSettings_AutoSaveLabel { } } + /// + /// Looks up a localized string similar to Check if a newer version is available at startup. + /// + public static string GeneralSettings_CheckVersion { + get { + return ResourceManager.GetString("GeneralSettings_CheckVersion", resourceCulture); + } + } + /// /// Looks up a localized string similar to Debug. /// @@ -2956,6 +3046,15 @@ public static string Rename_DeclarationType { } } + /// + /// Looks up a localized string similar to Please ensure that exactly 1 control is selected before renaming.. + /// + public static string RenameDialog_AmbiguousSelection { + get { + return ResourceManager.GetString("RenameDialog_AmbiguousSelection", resourceCulture); + } + } + /// /// Looks up a localized string similar to Rubberduck - Rename. /// @@ -3138,7 +3237,7 @@ public static string Rubberduck { } /// - /// Looks up a localized string similar to Build {0} ({1}). + /// Looks up a localized string similar to Version {0}. /// public static string Rubberduck_AboutBuild { get { @@ -5217,6 +5316,15 @@ public static string UnitTestSettings_TestModuleTemplateHeader { } } + /// + /// Looks up a localized string similar to Rubberduck version {0} is now available! Would you like to review the release notes now?. + /// + public static string VersionCheck_NewVersionAvailable { + get { + return ResourceManager.GetString("VersionCheck_NewVersionAvailable", resourceCulture); + } + } + /// /// Looks up a localized string similar to Warning. /// diff --git a/RetailCoder.VBE/UI/RubberduckUI.de.resx b/RetailCoder.VBE/UI/RubberduckUI.de.resx index cd74c54d73..156d2a7f76 100644 --- a/RetailCoder.VBE/UI/RubberduckUI.de.resx +++ b/RetailCoder.VBE/UI/RubberduckUI.de.resx @@ -371,8 +371,7 @@ Warnung: Alle eigenen Einstellungen gehen dabei verloren. Die Originaldatei wird Konnte das Rubberduck Add-In nicht laden - Build {0} ({1}) - 0: Version; 1: Architektur + Version BUG @@ -1051,7 +1050,7 @@ Wollen Sie trotzdem fortfahren? Über Rubberduck - © Copyright 2014-2016 Mathieu Guindon & Christopher McClellan + © Copyright 2014-2017 Mathieu Guindon & Christopher McClellan Spezieller Dank @@ -1824,43 +1823,43 @@ End Sub Referenzen - + Einstellungen für Inspektionen speichern - + Einstellungen für Todo-Liste speichern - + XML Datei (.xml)|*.xml|Rubberduck config file|*.config - + Allgemeine Einstellungen speichern - + Einstellungen für Todo-Liste Laden - + Einstellungen für Unit-Tests speichern - + Einstellungen für Unit-Tests laden - + Einstellungen für Inspektionen laden - + Export - + Einstellungen für Einrückung speichern - + Einstellungen für Einrückung laden - + Allgemeine Einstellungen Laden - + Import - + \ No newline at end of file diff --git a/RetailCoder.VBE/UI/RubberduckUI.fr.resx b/RetailCoder.VBE/UI/RubberduckUI.fr.resx index 50f3099fd8..cafab30a78 100644 --- a/RetailCoder.VBE/UI/RubberduckUI.fr.resx +++ b/RetailCoder.VBE/UI/RubberduckUI.fr.resx @@ -375,8 +375,7 @@ Attention: les valeurs personnalisées seront perdues. Le fichier original se Une erreur est survenue lors du chargement du complément Rubberduck. - Version {0} ({1}) - 0: Version; 1: ProcessorArchitecture + Version {0} BUG @@ -1309,7 +1308,7 @@ Icônes "Fugue" par Yusuke Kamiyamane Clé invalide - © Copyright 2014-2016 Mathieu Guindon & Christopher McClellan + © Copyright 2014-2017 Mathieu Guindon & Christopher McClellan cette procédure s'exécute une seule fois par module @@ -1867,4 +1866,10 @@ End Sub Import + + Vérifier si une nouvelle version est diponible au démarrage + + + La version {0} de Rubberduck est maintenant disponible! Souhaitez-vous consulter les notes de mise à jour maintenant? + \ No newline at end of file diff --git a/RetailCoder.VBE/UI/RubberduckUI.resx b/RetailCoder.VBE/UI/RubberduckUI.resx index 82043fb2e2..ea3a913f47 100644 --- a/RetailCoder.VBE/UI/RubberduckUI.resx +++ b/RetailCoder.VBE/UI/RubberduckUI.resx @@ -385,8 +385,7 @@ Warning: All customized settings will be lost. Your old file will be saved in ' Rubberduck Add-In could not be loaded - Build {0} ({1}) - 0: Version; 1: ProcessorArchitecture + Version {0} BUG @@ -709,6 +708,9 @@ Warning: All customized settings will be lost. Your old file will be saved in ' Renaming to '{0}' clashes with '{1}' in the same scope. Are you sure you want to proceed with this rename? + + + Please ensure that exactly 1 control is selected before renaming. Rename {0} @@ -723,7 +725,7 @@ Are you sure you want to proceed with this rename? About Rubberduck - © Copyright 2014-2016 Mathieu Guindon & Christopher McClellan + © Copyright 2014-2017 Mathieu Guindon & Christopher McClellan Special Thanks @@ -1911,7 +1913,45 @@ Would you like to import them to Rubberduck? runtime expression + + Assigned ByVal parameter QuickFix - Make Local Copy + + + Please specify a name to use for the local copy of ByVal {0} '{1}' + 0: DeclarationType; 1: IdentifierName + + + Specify Local Copy Variable Name + Indented Code Sample + + Rubberduck version {0} is now available! Would you like to review the release notes now? + + + Check if a newer version is available at startup + + + Variable names must begin with a letter. + + + Variable names cannot contain special characters other than underscores. + + + The local variable cannot be the same as the '{0}' parameter it replaces + {0} = proposed variable name. + + + '{0}' is already used in this scope. + {0} = proposed variable name. + + + The identifier '{0}' will trigger a "Use meaningful name" inspection result. Consider choosing a different name. + {0} = proposed variable name. + + + '{0}' is a reserved keyword. + {0} = proposed variable name. + \ No newline at end of file diff --git a/RetailCoder.VBE/UI/Settings/GeneralSettings.xaml b/RetailCoder.VBE/UI/Settings/GeneralSettings.xaml index 11fa4a712c..33133d644b 100644 --- a/RetailCoder.VBE/UI/Settings/GeneralSettings.xaml +++ b/RetailCoder.VBE/UI/Settings/GeneralSettings.xaml @@ -119,6 +119,9 @@ + + //------------------------------------------------------------------------------ -// Generated from C:\Users\hosch\Documents\Visual Studio 2015\Projects\Rubberduck\Rubberduck.Parsing\Grammar\VBALexer.g4 by ANTLR 4.3 +// Generated from C:\Dev\Rubberduck\Rubberduck.Parsing\Grammar\VBALexer.g4 by ANTLR 4.3 // Unreachable code detected #pragma warning disable 0162 diff --git a/Rubberduck.Parsing/Grammar/VBAParser.cs b/Rubberduck.Parsing/Grammar/VBAParser.cs index 93bac2f350..878c761d51 100644 --- a/Rubberduck.Parsing/Grammar/VBAParser.cs +++ b/Rubberduck.Parsing/Grammar/VBAParser.cs @@ -13450,14 +13450,14 @@ public IdentifierContext identifier() { case 1: EnterOuterAlt(_localctx, 1); { - State = 2184; untypedIdentifier(); + State = 2184; typedIdentifier(); } break; case 2: EnterOuterAlt(_localctx, 2); { - State = 2185; typedIdentifier(); + State = 2185; untypedIdentifier(); } break; } @@ -20544,7 +20544,7 @@ private bool upperCaseA_sempred(UpperCaseAContext _localctx, int predIndex) { "\x2\x2\x2\x883\x884\x5\x172\xBA\x2\x884\x14B\x3\x2\x2\x2\x885\x889\x5"+ "\x14E\xA8\x2\x886\x889\x5\x19C\xCF\x2\x887\x889\x5\x19A\xCE\x2\x888\x885"+ "\x3\x2\x2\x2\x888\x886\x3\x2\x2\x2\x888\x887\x3\x2\x2\x2\x889\x14D\x3"+ - "\x2\x2\x2\x88A\x88D\x5\x150\xA9\x2\x88B\x88D\x5\x152\xAA\x2\x88C\x88A"+ + "\x2\x2\x2\x88A\x88D\x5\x152\xAA\x2\x88B\x88D\x5\x150\xA9\x2\x88C\x88A"+ "\x3\x2\x2\x2\x88C\x88B\x3\x2\x2\x2\x88D\x14F\x3\x2\x2\x2\x88E\x88F\x5"+ "\x154\xAB\x2\x88F\x151\x3\x2\x2\x2\x890\x891\x5\x154\xAB\x2\x891\x892"+ "\x5\x16E\xB8\x2\x892\x153\x3\x2\x2\x2\x893\x898\a\xED\x2\x2\x894\x898"+ diff --git a/Rubberduck.Parsing/Grammar/VBAParser.g4 b/Rubberduck.Parsing/Grammar/VBAParser.g4 index 9b9f468d4a..841ee5f140 100644 --- a/Rubberduck.Parsing/Grammar/VBAParser.g4 +++ b/Rubberduck.Parsing/Grammar/VBAParser.g4 @@ -522,7 +522,7 @@ subscripts : subscript (whiteSpace? COMMA whiteSpace? subscript)*; subscript : (expression whiteSpace TO whiteSpace)? expression; unrestrictedIdentifier : identifier | statementKeyword | markerKeyword; -identifier : untypedIdentifier | typedIdentifier; +identifier : typedIdentifier | untypedIdentifier; untypedIdentifier : identifierValue; typedIdentifier : identifierValue typeHint; identifierValue : IDENTIFIER | keyword | foreignName | BF; diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj index 61385d76d1..30d729f326 100644 --- a/Rubberduck.Parsing/Rubberduck.Parsing.csproj +++ b/Rubberduck.Parsing/Rubberduck.Parsing.csproj @@ -42,7 +42,8 @@ false - + + False ..\packages\Antlr4.Runtime.4.3.0\lib\net45\Antlr4.Runtime.net45.dll @@ -110,6 +111,7 @@ + @@ -144,6 +146,8 @@ + + diff --git a/Rubberduck.Parsing/SymbolList.cs b/Rubberduck.Parsing/SymbolList.cs new file mode 100644 index 0000000000..9af694b0d1 --- /dev/null +++ b/Rubberduck.Parsing/SymbolList.cs @@ -0,0 +1,58 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Rubberduck.Parsing.Grammar; + +namespace Rubberduck.Parsing +{ + public static class SymbolList + { + public static readonly IReadOnlyList ValueTypes = new[] + { + Tokens.Boolean, + Tokens.Byte, + Tokens.Currency, + Tokens.Date, + Tokens.Decimal, + Tokens.Double, + Tokens.Integer, + Tokens.Long, + Tokens.LongLong, + Tokens.LongPtr, + Tokens.Single, + Tokens.String, + Tokens.Variant, + }; + + public static readonly IReadOnlyList BaseTypes = new[] + { + Tokens.Boolean.ToUpper(), + Tokens.Byte.ToUpper(), + Tokens.Currency.ToUpper(), + Tokens.Date.ToUpper(), + Tokens.Decimal.ToUpper(), + Tokens.Double.ToUpper(), + Tokens.Integer.ToUpper(), + Tokens.Long.ToUpper(), + Tokens.LongLong.ToUpper(), + Tokens.LongPtr.ToUpper(), + Tokens.Single.ToUpper(), + Tokens.String.ToUpper(), + Tokens.Variant.ToUpper(), + Tokens.Object.ToUpper(), + Tokens.Any.ToUpper() + }; + + public static readonly IDictionary TypeHintToTypeName = new Dictionary + { + { "%", Tokens.Integer }, + { "&", Tokens.Long }, + { "@", Tokens.Decimal }, + { "!", Tokens.Single }, + { "#", Tokens.Double }, + { "$", Tokens.String } + }; + } +} diff --git a/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs b/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs index 6e8e8d2790..84ef6faf56 100644 --- a/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs +++ b/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs @@ -45,10 +45,15 @@ public static bool IsMemberAccessible(Declaration callingProject, Declaration ca { return true; } + if (calleeMember.IsBuiltIn && calleeMember.Accessibility > Accessibility.Friend) + { + return true; + } var memberModule = Declaration.GetModuleParent(calleeMember); return IsModuleAccessible(callingProject, callingModule, memberModule) && (calleeMember.DeclarationType.HasFlag(DeclarationType.EnumerationMember) || calleeMember.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember) + || calleeMember.DeclarationType.HasFlag(DeclarationType.ComAlias) || HasPublicScope(calleeMember) || (IsEnclosingProject(callingProject, memberModule) && IsAccessibleThroughoutTheSameProject(calleeMember))); } diff --git a/Rubberduck.Parsing/Symbols/AliasDeclaration.cs b/Rubberduck.Parsing/Symbols/AliasDeclaration.cs new file mode 100644 index 0000000000..e8d7c566a3 --- /dev/null +++ b/Rubberduck.Parsing/Symbols/AliasDeclaration.cs @@ -0,0 +1,26 @@ +using Rubberduck.Parsing.ComReflection; +using Rubberduck.VBEditor; + +namespace Rubberduck.Parsing.Symbols +{ + public class AliasDeclaration : Declaration + { + public AliasDeclaration(ComAlias alias, Declaration parent, QualifiedModuleName module) + : base( + module.QualifyMemberName(alias.Name), + parent, + parent, + alias.TypeName, + null, + false, + false, + Accessibility.Public, + DeclarationType.ComAlias, + null, + Selection.Home, + false, + null, + true) + { } + } +} diff --git a/Rubberduck.Parsing/Symbols/Declaration.cs b/Rubberduck.Parsing/Symbols/Declaration.cs index 77497db371..6a149d9f62 100644 --- a/Rubberduck.Parsing/Symbols/Declaration.cs +++ b/Rubberduck.Parsing/Symbols/Declaration.cs @@ -19,34 +19,6 @@ namespace Rubberduck.Parsing.Symbols [DebuggerDisplay("({DeclarationType}) {Accessibility} {IdentifierName} As {AsTypeName} | {Selection}")] public class Declaration : IEquatable { - public static readonly string[] BaseTypes = - { - "BOOLEAN", - "BYTE", - "CURRENCY", - "DATE", - "DOUBLE", - "INTEGER", - "LONG", - "LONGLONG", - "LONGPTR", - "SINGLE", - "STRING", - "VARIANT", - "OBJECT", - "ANY" - }; - - public static readonly IDictionary TypeHintToTypeName = new Dictionary - { - { "%", Tokens.Integer }, - { "&", Tokens.Long }, - { "@", Tokens.Decimal }, - { "!", Tokens.Single }, - { "#", Tokens.Double }, - { "$", Tokens.String } - }; - public Declaration( QualifiedMemberName qualifiedName, Declaration parentDeclaration, @@ -485,7 +457,7 @@ public bool AsTypeIsBaseType { get { - return string.IsNullOrWhiteSpace(AsTypeName) || BaseTypes.Contains(_asTypeName.ToUpperInvariant()); + return string.IsNullOrWhiteSpace(AsTypeName) || SymbolList.BaseTypes.Contains(_asTypeName.ToUpperInvariant()); } } diff --git a/Rubberduck.Parsing/Symbols/DeclarationType.cs b/Rubberduck.Parsing/Symbols/DeclarationType.cs index 8afdd30b37..1bc6c67746 100644 --- a/Rubberduck.Parsing/Symbols/DeclarationType.cs +++ b/Rubberduck.Parsing/Symbols/DeclarationType.cs @@ -63,6 +63,8 @@ public enum DeclarationType UnresolvedMember = 1 << 26, [DebuggerDisplay("BracketedExpression")] BracketedExpression = 1 << 27, + [DebuggerDisplay("ComAlias")] + ComAlias = 1 << 28 } public interface IIdentifier { IdentifierNode Identifier { get; } } diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceListener.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceListener.cs index 0505fb1a28..0d846dac75 100644 --- a/Rubberduck.Parsing/Symbols/IdentifierReferenceListener.cs +++ b/Rubberduck.Parsing/Symbols/IdentifierReferenceListener.cs @@ -169,6 +169,11 @@ public override void EnterRedimStmt(VBAParser.RedimStmtContext context) _resolver.Resolve(context); } + public override void EnterNameStmt(VBAParser.NameStmtContext context) + { + _resolver.Resolve(context); + } + public override void EnterEraseStmt(VBAParser.EraseStmtContext context) { _resolver.Resolve(context); diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs index 61eb9be810..f59d306c4c 100644 --- a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs +++ b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs @@ -380,6 +380,14 @@ public void Resolve(VBAParser.EraseStmtContext context) } } + public void Resolve(VBAParser.NameStmtContext context) + { + foreach (var expr in context.expression()) + { + ResolveDefault(expr); + } + } + private void ResolveFileNumber(VBAParser.FileNumberContext fileNumber) { if (fileNumber.markedFileNumber() != null) diff --git a/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs b/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs index 65f0b527f0..b336ae0059 100644 --- a/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs +++ b/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs @@ -41,7 +41,9 @@ public void Execute() private void AnnotateType(Declaration declaration) { - if (declaration.DeclarationType == DeclarationType.ClassModule || declaration.DeclarationType == DeclarationType.UserDefinedType) + if (declaration.DeclarationType == DeclarationType.ClassModule || + declaration.DeclarationType == DeclarationType.UserDefinedType || + declaration.DeclarationType == DeclarationType.ComAlias) { declaration.AsTypeDeclaration = declaration; return; @@ -52,7 +54,7 @@ private void AnnotateType(Declaration declaration) var typeContext = declaration.AsTypeContext; typeExpression = typeContext.type().complexType().GetText(); } - else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !Declaration.BaseTypes.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant())) + else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !SymbolList.BaseTypes.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant())) { typeExpression = declaration.AsTypeNameWithoutArrayDesignator; } diff --git a/Rubberduck.Parsing/VBA/ComponentParseTask.cs b/Rubberduck.Parsing/VBA/ComponentParseTask.cs index 1a88ff5641..3f319a5ce0 100644 --- a/Rubberduck.Parsing/VBA/ComponentParseTask.cs +++ b/Rubberduck.Parsing/VBA/ComponentParseTask.cs @@ -111,6 +111,16 @@ public void Start(CancellationToken token) Cause = exception }); } + catch (Exception exception) + { + Logger.Error(exception, "Exception thrown in thread {0}, ParseTaskID {1}.", Thread.CurrentThread.ManagedThreadId, _taskId); + var failedHandler = ParseFailure; + if (failedHandler != null) + failedHandler.Invoke(this, new ParseFailureArgs + { + Cause = exception + }); + } } private static string[] GetSanitizedCode(ICodeModule module) @@ -144,7 +154,7 @@ private static void StripLineNumbers(string[] lines) } } - continuing = code.EndsWith("_"); + continuing = code.EndsWith(" _"); } } diff --git a/Rubberduck.Parsing/VBA/ParseCoordinator.cs b/Rubberduck.Parsing/VBA/ParseCoordinator.cs index 99021d3d3a..a41ee656fa 100644 --- a/Rubberduck.Parsing/VBA/ParseCoordinator.cs +++ b/Rubberduck.Parsing/VBA/ParseCoordinator.cs @@ -18,7 +18,6 @@ using System.Runtime.InteropServices; using Rubberduck.VBEditor.Application; using Rubberduck.VBEditor.Extensions; -using Rubberduck.VBEditor.SafeComWrappers; // ReSharper disable LoopCanBeConvertedToQuery @@ -32,6 +31,7 @@ public class ParseCoordinator : IParseCoordinator private const int _maxDegreeOfDeclarationResolverParallelism = -1; private const int _maxDegreeOfReferenceResolverParallelism = -1; private const int _maxDegreeOfModuleStateChangeParallelism = -1; + private const int _maxReferenceLoadingConcurrency = -1; private readonly IDictionary, Attributes>> _componentAttributes = new Dictionary, Attributes>>(); @@ -62,7 +62,7 @@ public ParseCoordinator( _preprocessorFactory = preprocessorFactory; _customDeclarationLoaders = customDeclarationLoaders; _isTestScope = isTestScope; - _serializedDeclarationsPath = serializedDeclarationsPath + _serializedDeclarationsPath = serializedDeclarationsPath ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Rubberduck", "declarations"); _hostApp = _vbe.HostApplication(); @@ -72,19 +72,27 @@ public ParseCoordinator( // Do not access this from anywhere but ReparseRequested. // ReparseRequested needs to have a reference to all the cancellation tokens, // but the cancelees need to use their own token. - private readonly List _cancellationTokens = new List {new CancellationTokenSource()}; + private readonly List _cancellationTokens = new List { new CancellationTokenSource() }; + + private readonly Object _cancellationSyncObject = new Object(); + private readonly Object _parsingRunSyncObject = new Object(); private void ReparseRequested(object sender, EventArgs e) { - if (!_isTestScope) + CancellationToken token; + lock (_cancellationSyncObject) { Cancel(); - Task.Run(() => ParseAll(sender, _cancellationTokens[0])); + token = _cancellationTokens[0].Token; + } + + if (!_isTestScope) + { + Task.Run(() => ParseAll(sender, token)); } else { - Cancel(); - ParseInternal(_cancellationTokens[0]); + ParseInternal(token); } } @@ -109,7 +117,7 @@ private void Cancel(bool createNewTokenSource = true) public void Parse(CancellationTokenSource token) { SetSavedCancellationTokenSource(token); - ParseInternal(token); + ParseInternal(token.Token); } private void SetSavedCancellationTokenSource(CancellationTokenSource token) @@ -126,20 +134,47 @@ private void SetSavedCancellationTokenSource(CancellationTokenSource token) } } - private void ParseInternal(CancellationTokenSource token) + private void ParseInternal(CancellationToken token) + { + var lockTaken = false; + try + { + Monitor.Enter(_parsingRunSyncObject, ref lockTaken); + ParseInternalInternal(token); + } + catch (OperationCanceledException) + { + //This is the point to which the cancellation should break. + } + finally + { + if (lockTaken) Monitor.Exit(_parsingRunSyncObject); + } + } + + private void ParseInternalInternal(CancellationToken token) { + token.ThrowIfCancellationRequested(); + State.RefreshProjects(_vbe); + token.ThrowIfCancellationRequested(); + var components = State.Projects.SelectMany(project => project.VBComponents).ToList(); + token.ThrowIfCancellationRequested(); + // tests do not fire events when components are removed--clear components ClearComponentStateCacheForTests(); + token.ThrowIfCancellationRequested(); + // invalidation cleanup should go into ParseAsync? CleanUpComponentAttributes(components); - ExecuteCommonParseActivities(components, token); + token.ThrowIfCancellationRequested(); + ExecuteCommonParseActivities(components, token); } private void ClearComponentStateCacheForTests() @@ -161,54 +196,55 @@ private void CleanUpComponentAttributes(List components) } } - private void ExecuteCommonParseActivities(List toParse, CancellationTokenSource token) + private void ExecuteCommonParseActivities(List toParse, CancellationToken token) { - SetModuleStates(toParse, ParserState.Pending); + token.ThrowIfCancellationRequested(); + + SetModuleStates(toParse, ParserState.Pending, token); + + token.ThrowIfCancellationRequested(); - SyncComReferences(State.Projects); + SyncComReferences(State.Projects, token); RefreshDeclarationFinder(); + token.ThrowIfCancellationRequested(); + AddBuiltInDeclarations(); RefreshDeclarationFinder(); - if (token.IsCancellationRequested) - { - return; - } + token.ThrowIfCancellationRequested(); _projectDeclarations.Clear(); State.ClearBuiltInReferences(); - ParseComponents(toParse, token.Token); + ParseComponents(toParse, token); - if (token.IsCancellationRequested || State.Status >= ParserState.Error) - { - _state.IsEnabled = true; - return; - } + if (token.IsCancellationRequested || State.Status >= ParserState.Error) + { + throw new OperationCanceledException(token); + } - ResolveAllDeclarations(toParse, token.Token); + ResolveAllDeclarations(toParse, token); RefreshDeclarationFinder(); - if (token.IsCancellationRequested || State.Status >= ParserState.Error) - { - _state.IsEnabled = true; - return; - } + if (token.IsCancellationRequested || State.Status >= ParserState.Error) + { + throw new OperationCanceledException(token); + } State.SetStatusAndFireStateChanged(this, ParserState.ResolvedDeclarations); - if (token.IsCancellationRequested || State.Status >= ParserState.Error) - { - return; - } + if (token.IsCancellationRequested || State.Status >= ParserState.Error) + { + throw new OperationCanceledException(token); + } - ResolveAllReferences(token.Token); + ResolveAllReferences(token); - if (token.IsCancellationRequested || State.Status >= ParserState.Error) - { - return; - } + if (token.IsCancellationRequested || State.Status >= ParserState.Error) + { + throw new OperationCanceledException(token); + } State.RebuildSelectionCache(); } @@ -218,19 +254,27 @@ private void RefreshDeclarationFinder() State.RefreshFinder(_hostApp); } - private void SetModuleStates(List components, ParserState parserState) + private void SetModuleStates(List components, ParserState parserState, CancellationToken token) { var options = new ParallelOptions(); + options.CancellationToken = token; options.MaxDegreeOfParallelism = _maxDegreeOfModuleStateChangeParallelism; - Parallel.ForEach(components, options, component => State.SetModuleState(component, parserState, null, false)); - - State.EvaluateParserState(); + Parallel.ForEach(components, options, component => State.SetModuleState(component, parserState, token, null, false)); + + if (!token.IsCancellationRequested) + { + State.EvaluateParserState(); + } } private void ParseComponents(List components, CancellationToken token) { - SetModuleStates(components, ParserState.Parsing); + token.ThrowIfCancellationRequested(); + + SetModuleStates(components, ParserState.Parsing, token); + + token.ThrowIfCancellationRequested(); var options = new ParallelOptions(); options.CancellationToken = token; @@ -244,7 +288,7 @@ private void ParseComponents(List components, CancellationToken to { State.ClearStateCache(component); var finishedParseTask = FinishedParseComponentTask(component, token); - ProcessComponentParseResults(component, finishedParseTask); + ProcessComponentParseResults(component, finishedParseTask, token); } ); } @@ -252,8 +296,9 @@ private void ParseComponents(List components, CancellationToken to { if (exception.Flatten().InnerExceptions.All(ex => ex is OperationCanceledException)) { - return; + throw exception.InnerException; //This eliminates the stack trace, but for the cancellation, this is irrelevant. } + State.SetStatusAndFireStateChanged(this, ParserState.Error); throw; } @@ -288,20 +333,19 @@ private void ParseComponents(List components, CancellationToken to return tcs.Task; } - - private void ProcessComponentParseResults(IVBComponent component, Task finishedParseTask) + private void ProcessComponentParseResults(IVBComponent component, Task finishedParseTask, CancellationToken token) { if (finishedParseTask.IsFaulted) { //In contrast to the situation in the success scenario, the overall parser state is reevaluated immediately. - State.SetModuleState(component, ParserState.Error, finishedParseTask.Exception.InnerException as SyntaxErrorException); + State.SetModuleState(component, ParserState.Error, token, finishedParseTask.Exception.InnerException as SyntaxErrorException); } else if (finishedParseTask.IsCompleted) { var result = finishedParseTask.Result; lock (State) { - lock (component) + lock (component) { State.SetModuleAttributes(component, result.Attributes); State.AddParseTree(component, result.ParseTree); @@ -312,7 +356,7 @@ private void ProcessComponentParseResults(IVBComponent component, Task components, CancellationToken token) { - SetModuleStates(components, ParserState.ResolvingDeclarations); + token.ThrowIfCancellationRequested(); + + SetModuleStates(components, ParserState.ResolvingDeclarations, token); + + token.ThrowIfCancellationRequested(); var options = new ParallelOptions(); options.CancellationToken = token; @@ -334,7 +382,8 @@ private void ResolveAllDeclarations(List components, CancellationT { var qualifiedName = new QualifiedModuleName(component); ResolveDeclarations(qualifiedName.Component, - State.ParseTrees.Find(s => s.Key == qualifiedName).Value); + State.ParseTrees.Find(s => s.Key == qualifiedName).Value, + token); } ); } @@ -342,14 +391,15 @@ private void ResolveAllDeclarations(List components, CancellationT { if (exception.Flatten().InnerExceptions.All(ex => ex is OperationCanceledException)) { - return; + throw exception.InnerException; //This eliminates the stack trace, but for the cancellation, this is irrelevant. } + State.SetStatusAndFireStateChanged(this, ParserState.ResolverError); throw; } } private readonly ConcurrentDictionary _projectDeclarations = new ConcurrentDictionary(); - private void ResolveDeclarations(IVBComponent component, IParseTree tree) + private void ResolveDeclarations(IVBComponent component, IParseTree tree, CancellationToken token) { if (component == null) { return; } @@ -379,7 +429,7 @@ private void ResolveDeclarations(IVBComponent component, IParseTree tree) catch (Exception exception) { Logger.Error(exception, "Exception thrown acquiring declarations for '{0}' (thread {1}).", component.Name, Thread.CurrentThread.ManagedThreadId); - State.SetModuleState(component, ParserState.ResolverError); + State.SetModuleState(component, ParserState.ResolverError, token); } stopwatch.Stop(); Logger.Debug("{0}ms to resolve declarations for component {1}", stopwatch.ElapsedMilliseconds, component.Name); @@ -411,32 +461,48 @@ private Declaration CreateProjectDeclaration(QualifiedModuleName projectQualifie private void ResolveAllReferences(CancellationToken token) { + token.ThrowIfCancellationRequested(); + var components = State.ParseTrees.Select(kvp => kvp.Key.Component).ToList(); - SetModuleStates(components, ParserState.ResolvingReferences); + token.ThrowIfCancellationRequested(); + + SetModuleStates(components, ParserState.ResolvingReferences, token); + + token.ThrowIfCancellationRequested(); + ExecuteCompilationPasses(); + token.ThrowIfCancellationRequested(); + var options = new ParallelOptions(); options.CancellationToken = token; options.MaxDegreeOfParallelism = _maxDegreeOfReferenceResolverParallelism; - try { Parallel.For(0, State.ParseTrees.Count, options, - (index) => ResolveReferences(State.DeclarationFinder, State.ParseTrees[index].Key.Component, State.ParseTrees[index].Value) + (index) => ResolveReferences(State.DeclarationFinder, State.ParseTrees[index].Key, State.ParseTrees[index].Value, token) ); } catch (AggregateException exception) { if (exception.Flatten().InnerExceptions.All(ex => ex is OperationCanceledException)) { - return; + throw exception.InnerException; //This eliminates the stack trace, but for the cancellation, this is irrelevant. } + State.SetStatusAndFireStateChanged(this, ParserState.ResolverError); throw; } + token.ThrowIfCancellationRequested(); + AddUndeclaredVariablesToDeclarations(); + //This is here and not in the calling method because it has to happen before the ready state is reached. + //RefreshDeclarationFinder(); //Commented out because it breaks the unresolved and undeclared collections. + + token.ThrowIfCancellationRequested(); + State.EvaluateParserState(); } @@ -452,11 +518,12 @@ private void ExecuteCompilationPasses() passes.ForEach(p => p.Execute()); } - private void ResolveReferences(DeclarationFinder finder, IVBComponent component, IParseTree tree) + private void ResolveReferences(DeclarationFinder finder, QualifiedModuleName qualifiedName, IParseTree tree, CancellationToken token) { - Debug.Assert(State.GetModuleState(component) == ParserState.ResolvingReferences); + Debug.Assert(State.GetModuleState(qualifiedName.Component) == ParserState.ResolvingReferences || token.IsCancellationRequested); + + token.ThrowIfCancellationRequested(); - var qualifiedName = new QualifiedModuleName(component); Logger.Debug("Resolving identifier references in '{0}'... (thread {1})", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId); var resolver = new IdentifierReferenceResolver(qualifiedName, finder); @@ -470,16 +537,20 @@ private void ResolveReferences(DeclarationFinder finder, IVBComponent component, var watch = Stopwatch.StartNew(); walker.Walk(listener, tree); watch.Stop(); - Logger.Debug("Binding resolution done for component '{0}' in {1}ms (thread {2})", component.Name, + Logger.Debug("Binding resolution done for component '{0}' in {1}ms (thread {2})", qualifiedName.Name, watch.ElapsedMilliseconds, Thread.CurrentThread.ManagedThreadId); //Evaluation of the overall status has to be defered to allow processing of undeclared variables before setting the ready state. - State.SetModuleState(component, ParserState.Ready,null,false); + State.SetModuleState(qualifiedName.Component, ParserState.Ready, token, null, false); + } + catch (OperationCanceledException) + { + throw; //We do not want to set an error state if the exception was just caused by some cancellation. } catch (Exception exception) { - Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", component.Name, Thread.CurrentThread.ManagedThreadId); - State.SetModuleState(component, ParserState.ResolverError); + Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId); + State.SetModuleState(qualifiedName.Component, ParserState.ResolverError, token); } } } @@ -497,19 +568,63 @@ private void AddUndeclaredVariablesToDeclarations() /// /// Starts parsing all components of all unprotected VBProjects associated with the VBE-Instance passed to the constructor of this parser instance. /// - private void ParseAll(object requestor, CancellationTokenSource token) + private void ParseAll(object requestor, CancellationToken token) { + Stopwatch watch = null; + var lockTaken = false; + try + { + Monitor.Enter(_parsingRunSyncObject, ref lockTaken); + + watch = Stopwatch.StartNew(); + Logger.Debug("Parsing run started. (thread {0}).", Thread.CurrentThread.ManagedThreadId); + + ParseAllInternal(requestor, token); + } + catch (OperationCanceledException) + { + //This is the point to which the cancellation should break. + Logger.Debug("Parsing run got canceled. (thread {0}).", Thread.CurrentThread.ManagedThreadId); + } + catch (Exception exception) + { + Logger.Error(exception, "Unexpected exception thrown in parsing run. (thread {0}).", Thread.CurrentThread.ManagedThreadId); + State.SetStatusAndFireStateChanged(this, ParserState.Error); + } + finally + { + if (watch != null && watch.IsRunning) watch.Stop(); + if (lockTaken) Monitor.Exit(_parsingRunSyncObject); + } + if (watch != null) Logger.Debug("Parsing run finished after {0}s. (thread {1}).", watch.Elapsed.Seconds, Thread.CurrentThread.ManagedThreadId); + } + + + private void ParseAllInternal(object requestor, CancellationToken token) + { + token.ThrowIfCancellationRequested(); + State.RefreshProjects(_vbe); - + + token.ThrowIfCancellationRequested(); + var components = State.Projects.SelectMany(project => project.VBComponents).ToList(); - var componentsRemoved = ClearStateCacheForRemovedComponents(components); + token.ThrowIfCancellationRequested(); + + var componentsRemoved = ClearStateCashForRemovedComponents(components); + + token.ThrowIfCancellationRequested(); // invalidation cleanup should go into ParseAsync? CleanUpComponentAttributes(components); - var toParse = components.Where(component => State.IsNewOrModified(component)).ToList(); - + token.ThrowIfCancellationRequested(); + + var toParse = components.Where(component => State.IsNewOrModified(component)).ToList(); + + token.ThrowIfCancellationRequested(); + if (toParse.Count == 0) { if (componentsRemoved) // trigger UI updates @@ -521,14 +636,16 @@ private void ParseAll(object requestor, CancellationTokenSource token) //return; // returning here leaves state in 'ResolvedDeclarations' when a module is removed, which disables refresh } + token.ThrowIfCancellationRequested(); + ExecuteCommonParseActivities(toParse, token); } /// - /// Clears state cache for removed components. + /// Clears state cach for removed components. /// Returns whether components have been removed. /// - private bool ClearStateCacheForRemovedComponents(List components) + private bool ClearStateCashForRemovedComponents(List components) { var removedModuledecalrations = RemovedModuleDeclarations(components); var componentRemoved = removedModuledecalrations.Any(); @@ -561,7 +678,7 @@ private void AddBuiltInDeclarations() } catch (Exception exception) { - Logger.Error(exception); + Logger.Error(exception, "Exception thrown adding built-in declarations. (thread {0}).", Thread.CurrentThread.ManagedThreadId); } } } @@ -591,7 +708,7 @@ private string GetReferenceProjectId(IReference reference, IReadOnlyList projects) + private void SyncComReferences(IReadOnlyList projects, CancellationToken token) { - var loadTasks = new List(); - var unmapped = new List(); + var unmapped = new ConcurrentBag(); - foreach (var vbProject in projects) + var referencesToLoad = GetReferencesToLoadAndSaveReferencePriority(projects); + + State.OnStatusMessageUpdate(ParserState.LoadingReference.ToString()); + + var referenceLoadingTaskScheduler = ThrottelingTaskScheduler(_maxReferenceLoadingConcurrency); + + //Parallel.ForEach is not used because loading the references can contain IO-bound operations. + var loadTasks = new List(); + foreach(var reference in referencesToLoad) { - var projectId = QualifiedModuleName.GetProjectId(vbProject); - var references = vbProject.References; - { - // use a 'for' loop to store the order of references as a 'priority'. - // reference resolver needs this to know which declaration to prioritize when a global identifier exists in multiple libraries. - for (var priority = 1; priority <= references.Count; priority++) - { - var reference = references[priority]; - if (reference.IsBroken) - { - continue; - } - - // skip loading Rubberduck.tlb (GUID is defined in AssemblyInfo.cs) - if (reference.Guid == "{E07C841C-14B4-4890-83E9-8C80B06DD59D}") - { - // todo: figure out why Rubberduck.tlb *sometimes* throws - //continue; - } - var referencedProjectId = GetReferenceProjectId(reference, projects); - - ReferencePriorityMap map = null; - foreach (var item in _projectReferences) - { - if (item.ReferencedProjectId == referencedProjectId) - { - map = map != null ? null : item; - } - } - - if (map == null) - { - map = new ReferencePriorityMap(referencedProjectId) {{projectId, priority}}; - _projectReferences.Add(map); - } - else - { - map[projectId] = priority; - } - - if (!map.IsLoaded) - { - State.OnStatusMessageUpdate(ParserState.LoadingReference.ToString()); - - var localReference = reference; - - loadTasks.Add( - Task.Run(() => - { - try - { - Logger.Trace(string.Format("Loading referenced type '{0}'.", localReference.Name)); - - var comReflector = new ReferencedDeclarationsCollector(State, localReference, _serializedDeclarationsPath); - if (comReflector.SerializedVersionExists) - { - Logger.Trace(string.Format("Deserializing reference '{0}'.", localReference.Name)); - foreach (var declaration in comReflector.LoadDeclarationsFromXml()) - { - State.AddDeclaration(declaration); - } - } - else - { - Logger.Trace(string.Format("COM reflecting reference '{0}'.", localReference.Name)); - foreach (var declaration in comReflector.LoadDeclarationsFromLibrary()) - { - State.AddDeclaration(declaration); - } - } - } - catch (Exception exception) - { - unmapped.Add(reference); - Logger.Warn(string.Format("Types were not loaded from referenced type library '{0}'.", reference.Name)); - Logger.Error(exception); - } - })); - map.IsLoaded = true; - } - } - } + var localReference = reference; + loadTasks.Add(Task.Factory.StartNew( + () => LoadReference(localReference, unmapped), + token, + TaskCreationOptions.None, + referenceLoadingTaskScheduler + )); } - var mappedIds = new List(); - foreach (var item in _projectReferences) + var notMappedReferences = NonMappedReferences(projects); + foreach (var item in notMappedReferences) { - mappedIds.Add(item.ReferencedProjectId); + unmapped.Add(item); } - foreach (var project in projects) + try { - var references = project.References; + Task.WaitAll(loadTasks.ToArray(), token); + } + catch (AggregateException exception) + { + if (exception.Flatten().InnerExceptions.All(ex => ex is OperationCanceledException)) { - foreach (var item in references) - { - if (!mappedIds.Contains(GetReferenceProjectId(item, projects))) - { - unmapped.Add(item); - } - } + throw exception.InnerException; //This eliminates the stack trace, but for the cancellation, this is irrelevant. } + State.SetStatusAndFireStateChanged(this, ParserState.Error); + throw; } - - Task.WaitAll(loadTasks.ToArray()); + token.ThrowIfCancellationRequested(); foreach (var reference in unmapped) { @@ -722,129 +770,153 @@ private void SyncComReferences(IReadOnlyList projects) } } - private void UnloadComReference(IReference reference, IReadOnlyList projects) + private List GetReferencesToLoadAndSaveReferencePriority(IReadOnlyList projects) { - var referencedProjectId = GetReferenceProjectId(reference, projects); + var referencesToLoad = new List(); - ReferencePriorityMap map = null; - foreach (var item in _projectReferences) + foreach (var vbProject in projects) { - if (item.ReferencedProjectId == referencedProjectId) + var projectId = QualifiedModuleName.GetProjectId(vbProject); + var references = vbProject.References; + + // use a 'for' loop to store the order of references as a 'priority'. + // reference resolver needs this to know which declaration to prioritize when a global identifier exists in multiple libraries. + for (var priority = 1; priority <= references.Count; priority++) { - map = map != null ? null : item; + var reference = references[priority]; + if (reference.IsBroken) + { + continue; + } + + // skip loading Rubberduck.tlb (GUID is defined in AssemblyInfo.cs) + if (reference.Guid == "{E07C841C-14B4-4890-83E9-8C80B06DD59D}") + { + // todo: figure out why Rubberduck.tlb *sometimes* throws + //continue; + } + var referencedProjectId = GetReferenceProjectId(reference, projects); + + var map = _projectReferences.FirstOrDefault(item => item.ReferencedProjectId == referencedProjectId); + + if (map == null) + { + map = new ReferencePriorityMap(referencedProjectId) { { projectId, priority } }; + _projectReferences.Add(map); + } + else + { + map[projectId] = priority; + } + + if (!map.IsLoaded) + { + referencesToLoad.Add(reference); + map.IsLoaded = true; + } } } - - if (map == null || !map.IsLoaded) + return referencesToLoad; + } + + private TaskScheduler ThrottelingTaskScheduler(int maxLevelOfConcurrency) + { + if (maxLevelOfConcurrency <= 0) { - // we're removing a reference we weren't tracking? ...this shouldn't happen. - //Debug.Assert(false); - return; + return TaskScheduler.Default; } - map.Remove(referencedProjectId); - if (map.Count == 0) + else { - _projectReferences.Remove(map); - State.RemoveBuiltInDeclarations(reference); + var taskSchedulerPair = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, maxLevelOfConcurrency); + return taskSchedulerPair.ConcurrentScheduler; } } - - private readonly ConcurrentDictionary _projectDeclarations = new ConcurrentDictionary(); - private void ResolveDeclarations(IVBComponent component, IParseTree tree) + private void LoadReference(IReference localReference, ConcurrentBag unmapped) { - if (component == null) { return; } - - var qualifiedModuleName = new QualifiedModuleName(component); - - var stopwatch = Stopwatch.StartNew(); + Logger.Trace(string.Format("Loading referenced type '{0}'.", localReference.Name)); + var comReflector = new ReferencedDeclarationsCollector(State, localReference, _serializedDeclarationsPath); try { - var project = component.Collection.Parent; - var projectQualifiedName = new QualifiedModuleName(project); - Declaration projectDeclaration; - if (!_projectDeclarations.TryGetValue(projectQualifiedName.ProjectId, out projectDeclaration)) + if (comReflector.SerializedVersionExists) { - projectDeclaration = CreateProjectDeclaration(projectQualifiedName, project); - _projectDeclarations.AddOrUpdate(projectQualifiedName.ProjectId, projectDeclaration, (s, c) => projectDeclaration); - State.AddDeclaration(projectDeclaration); + LoadReferenceByDeserialization(localReference, comReflector); } - Logger.Debug("Creating declarations for module {0}.", qualifiedModuleName.Name); - - var declarationsListener = new DeclarationSymbolsListener(State, qualifiedModuleName, component.Type, State.GetModuleAnnotations(component), State.GetModuleAttributes(component), projectDeclaration); - ParseTreeWalker.Default.Walk(declarationsListener, tree); - foreach (var createdDeclaration in declarationsListener.CreatedDeclarations) + else { - State.AddDeclaration(createdDeclaration); + LoadReferenceByCOMReflection(localReference, comReflector); } } catch (Exception exception) { - Logger.Error(exception, "Exception thrown acquiring declarations for '{0}' (thread {1}).", component.Name, Thread.CurrentThread.ManagedThreadId); - State.SetModuleState(component, ParserState.ResolverError); + unmapped.Add(localReference); + Logger.Warn(string.Format("Types were not loaded from referenced type library '{0}'.", localReference.Name)); + Logger.Error(exception); } - stopwatch.Stop(); - Logger.Debug("{0}ms to resolve declarations for component {1}", stopwatch.ElapsedMilliseconds, component.Name); } - private Declaration CreateProjectDeclaration(QualifiedModuleName projectQualifiedName, IVBProject project) + private void LoadReferenceByDeserialization(IReference localReference, ReferencedDeclarationsCollector comReflector) { - var qualifiedName = projectQualifiedName.QualifyMemberName(project.Name); - var projectId = qualifiedName.QualifiedModuleName.ProjectId; - var projectDeclaration = new ProjectDeclaration(qualifiedName, project.Name, false, project); - - var references = new List(); - foreach (var item in _projectReferences) + Logger.Trace(string.Format("Deserializing reference '{0}'.", localReference.Name)); + var declarations = comReflector.LoadDeclarationsFromXml(); + foreach (var declaration in declarations) { - if (item.ContainsKey(projectId)) - { - references.Add(item); - } + State.AddDeclaration(declaration); } + } - foreach (var reference in references) + private void LoadReferenceByCOMReflection(IReference localReference, ReferencedDeclarationsCollector comReflector) + { + Logger.Trace(string.Format("COM reflecting reference '{0}'.", localReference.Name)); + var declarations = comReflector.LoadDeclarationsFromLibrary(); + foreach (var declaration in declarations) { - int priority = reference[projectId]; - projectDeclaration.AddProjectReference(reference.ReferencedProjectId, priority); + State.AddDeclaration(declaration); } - return projectDeclaration; + } + + private List NonMappedReferences(IReadOnlyList projects) + { + var mappedIds = _projectReferences.Select(item => item.ReferencedProjectId).ToHashSet(); + var references = projects.SelectMany(project => project.References); + return references.Where(item => !mappedIds.Contains(GetReferenceProjectId(item, projects))).ToList(); } - private void ResolveReferences(DeclarationFinder finder, IVBComponent component, IParseTree tree) + private void UnloadComReference(IReference reference, IReadOnlyList projects) { - Debug.Assert(State.GetModuleState(component) == ParserState.ResolvingReferences); - - var qualifiedName = new QualifiedModuleName(component); - Logger.Debug("Resolving identifier references in '{0}'... (thread {1})", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId); + var referencedProjectId = GetReferenceProjectId(reference, projects); - var resolver = new IdentifierReferenceResolver(qualifiedName, finder); - var listener = new IdentifierReferenceListener(resolver); + ReferencePriorityMap map = null; + try + { + map = _projectReferences.SingleOrDefault(item => item.ReferencedProjectId == referencedProjectId); + } + catch (InvalidOperationException exception) + { + //There are multiple maps with the same referencedProjectId. That should not happen. (ghost?). + Logger.Error(exception, "Failed To unload com reference with referencedProjectID {0} because RD stores multiple instances of it.", referencedProjectId); + return; + } - if (!string.IsNullOrWhiteSpace(tree.GetText().Trim())) + if (map == null || !map.IsLoaded) { - var walker = new ParseTreeWalker(); - try - { - var watch = Stopwatch.StartNew(); - walker.Walk(listener, tree); - watch.Stop(); - Logger.Debug("Binding resolution done for component '{0}' in {1}ms (thread {2})", component.Name, - watch.ElapsedMilliseconds, Thread.CurrentThread.ManagedThreadId); + // we're removing a reference we weren't tracking? ...this shouldn't happen. + return; + } - State.SetModuleState(component, ParserState.Ready); - } - catch (Exception exception) - { - Logger.Error(exception, "Exception thrown resolving '{0}' (thread {1}).", component.Name, Thread.CurrentThread.ManagedThreadId); - State.SetModuleState(component, ParserState.ResolverError); - } + map.Remove(referencedProjectId); + if (map.Count == 0) + { + _projectReferences.Remove(map); + State.RemoveBuiltInDeclarations(reference); } } + public void Dispose() { State.ParseRequest -= ReparseRequested; Cancel(false); } } -} +} \ No newline at end of file diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs index cf370dd822..a6939c46d8 100644 --- a/Rubberduck.Parsing/VBA/RubberduckParserState.cs +++ b/Rubberduck.Parsing/VBA/RubberduckParserState.cs @@ -2,6 +2,7 @@ using System.Collections.Concurrent; using System.Collections.Generic; using System.Diagnostics; +using System.Linq; using System.Runtime.InteropServices; using System.Threading; using Antlr4.Runtime; @@ -70,8 +71,8 @@ internal void RefreshFinder(IHostApplication host) DeclarationFinder = new DeclarationFinder(AllDeclarations, AllAnnotations, host); } - - public RubberduckParserState(ISinks sinks) + private IVBE _vbe; + public RubberduckParserState(IVBE vbe) { var values = Enum.GetValues(typeof(ParserState)); foreach (var value in values) @@ -79,28 +80,36 @@ public RubberduckParserState(ISinks sinks) States.Add((ParserState)value); } - _sinks = sinks; - if (sinks != null) + _vbe = vbe; + + if (_vbe != null && _vbe.VBProjects != null) { - _sinks.ProjectAdded += Sinks_ProjectAdded; - _sinks.ProjectRemoved += Sinks_ProjectRemoved; - _sinks.ProjectRenamed += Sinks_ProjectRenamed; - _sinks.ComponentAdded += Sinks_ComponentAdded; - _sinks.ComponentRemoved += Sinks_ComponentRemoved; - _sinks.ComponentRenamed += Sinks_ComponentRenamed; + _vbe.VBProjects.ProjectAdded += Sinks_ProjectAdded; + _vbe.VBProjects.ProjectRemoved += Sinks_ProjectRemoved; + _vbe.VBProjects.ProjectRenamed += Sinks_ProjectRenamed; + foreach (var project in _vbe.VBProjects.Where(proj => proj.VBComponents != null)) + { + AddComponentEventHandlers(project); + } } IsEnabled = true; } - private bool _started; - public void StartEventSinks() + #region Event Handling + + private void AddComponentEventHandlers(IVBProject project) + { + project.VBComponents.ComponentAdded += Sinks_ComponentAdded; + project.VBComponents.ComponentRemoved += Sinks_ComponentRemoved; + project.VBComponents.ComponentRenamed += Sinks_ComponentRenamed; + } + + private void RemoveComponentEventHandlers(IVBProject project) { - if (!_started && _sinks != null) - { - _sinks.Start(); - _started = true; - } + project.VBComponents.ComponentAdded -= Sinks_ComponentAdded; + project.VBComponents.ComponentRemoved -= Sinks_ComponentRemoved; + project.VBComponents.ComponentRenamed -= Sinks_ComponentRenamed; } private void Sinks_ProjectAdded(object sender, ProjectEventArgs e) @@ -108,8 +117,9 @@ private void Sinks_ProjectAdded(object sender, ProjectEventArgs e) if (!e.Project.VBE.IsInDesignMode) { return; } Logger.Debug("Project '{0}' was added.", e.ProjectId); + AddComponentEventHandlers(e.Project); - RefreshProjects(e.Project.VBE); // note side-effect: assigns ProjectId/HelpFile + RefreshProjects(_vbe); // note side-effect: assigns ProjectId/HelpFile OnParseRequested(sender); } @@ -118,6 +128,7 @@ private void Sinks_ProjectRemoved(object sender, ProjectEventArgs e) if (!e.Project.VBE.IsInDesignMode) { return; } Debug.Assert(e.ProjectId != null); + RemoveComponentEventHandlers(e.Project); RemoveProject(e.ProjectId, true); OnParseRequested(sender); @@ -222,6 +233,8 @@ public void OnStatusMessageUpdate(string message) } } + #endregion + /// /// Refreshes our list of cached projects. /// Be sure to reparse after calling this in case there @@ -305,6 +318,7 @@ private void OnStateChanged(object requestor, ParserState state = ParserState.Pe } public event EventHandler ModuleStateChanged; + //Never spawn new threads changing module states in the handler! This will cause deadlocks. private void OnModuleStateChanged(IVBComponent component, ParserState state, ParserState oldState) { var handler = ModuleStateChanged; @@ -315,6 +329,15 @@ private void OnModuleStateChanged(IVBComponent component, ParserState state, Par } } + + public void SetModuleState(IVBComponent component, ParserState state, CancellationToken token, SyntaxErrorException parserError = null, bool evaluateOverallState = true) + { + if (!token.IsCancellationRequested) + { + SetModuleState(component, state, parserError, evaluateOverallState); + } + } + public void SetModuleState(IVBComponent component, ParserState state, SyntaxErrorException parserError = null, bool evaluateOverallState = true) { if (AllUserDeclarations.Count > 0) @@ -361,6 +384,7 @@ public void SetModuleState(IVBComponent component, ParserState state, SyntaxErro } } + public void EvaluateParserState() { lock (_statusLockObject) Status = OverallParserStateFromModuleStates(); @@ -1067,7 +1091,6 @@ public void RemoveBuiltInDeclarations(IReference reference) } private bool _isDisposed; - private readonly ISinks _sinks; public void Dispose() { @@ -1086,14 +1109,15 @@ public void Dispose() CoClasses.Clear(); } - if (_sinks != null) + if (_vbe != null && _vbe.VBProjects != null) { - _sinks.ComponentAdded -= Sinks_ComponentAdded; - _sinks.ComponentRemoved -= Sinks_ComponentRemoved; - _sinks.ComponentRenamed -= Sinks_ComponentRenamed; - _sinks.ProjectAdded -= Sinks_ProjectAdded; - _sinks.ProjectRemoved -= Sinks_ProjectRemoved; - _sinks.ProjectRenamed -= Sinks_ProjectRenamed; + _vbe.VBProjects.ProjectAdded -= Sinks_ProjectAdded; + _vbe.VBProjects.ProjectRemoved -= Sinks_ProjectRemoved; + _vbe.VBProjects.ProjectRenamed -= Sinks_ProjectRenamed; + foreach (var project in _vbe.VBProjects.Where(proj => proj.VBComponents != null)) + { + RemoveComponentEventHandlers(project); + } } _moduleStates.Clear(); diff --git a/Rubberduck.VBEEditor/Application/AccessApp.cs b/Rubberduck.VBEEditor/Application/AccessApp.cs index fc71c5a3a4..41e1143891 100644 --- a/Rubberduck.VBEEditor/Application/AccessApp.cs +++ b/Rubberduck.VBEEditor/Application/AccessApp.cs @@ -20,15 +20,7 @@ public override void Run(dynamic declaration) public List FormDeclarations(QualifiedModuleName qualifiedModuleName) { - //TODO: Determine if component is Form/Report - string filePath = Path.Combine(ExportPath, qualifiedModuleName.Name + MSAccessComponentType.Form.FileExtension()); - Application.SaveAsText(AcObjectType.acForm, qualifiedModuleName.Name, filePath); - var code = File.ReadAllText(filePath); - File.Delete(filePath); - - - - + //TODO: Drop in the optimized version that uses line indentations return new List(); } diff --git a/Rubberduck.VBEEditor/Events/ConnectionPointInfo.cs b/Rubberduck.VBEEditor/Events/ConnectionPointInfo.cs deleted file mode 100644 index 397dccad8d..0000000000 --- a/Rubberduck.VBEEditor/Events/ConnectionPointInfo.cs +++ /dev/null @@ -1,48 +0,0 @@ -using System; -using System.Runtime.InteropServices.ComTypes; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; - -namespace Rubberduck.VBEditor.Events -{ - public class ConnectionPointInfo - { - public ConnectionPointInfo(IConnectionPoint connectionPoint) - { - _connectionPoint = connectionPoint; - } - - private readonly IConnectionPoint _connectionPoint; - private int? _cookie; - - public bool HasConnectionPoint { get { return _connectionPoint != null; } } - - public void Advise(IVBComponentsEventsSink componentsEventsSink) - { - if (_cookie.HasValue) { throw new InvalidOperationException(); } - int cookie; - _connectionPoint.Advise(componentsEventsSink, out cookie); - _cookie = cookie; - } - - public void Advise(IVBProjectsEventsSink projectsEventsSink) - { - if (_cookie.HasValue) { throw new InvalidOperationException(); } - int cookie; - _connectionPoint.Advise(projectsEventsSink, out cookie); - _cookie = cookie; - } - - public void Unadvise() - { - if (!_cookie.HasValue) { throw new InvalidOperationException(); } - try - { - _connectionPoint.Unadvise(_cookie.Value); - } - catch (InvalidOperationException) - { - // hey, we tried. - } - } - } -} \ No newline at end of file diff --git a/Rubberduck.VBEEditor/Events/ISinks.cs b/Rubberduck.VBEEditor/Events/ISinks.cs deleted file mode 100644 index c8fb155d03..0000000000 --- a/Rubberduck.VBEEditor/Events/ISinks.cs +++ /dev/null @@ -1,23 +0,0 @@ -using System; - -namespace Rubberduck.VBEditor.Events -{ - public interface ISinks - { - void Start(); - void Stop(); - bool ComponentSinksEnabled { get; set; } - - event EventHandler ProjectActivated; - event EventHandler ProjectAdded; - event EventHandler ProjectRemoved; - event EventHandler ProjectRenamed; - - event EventHandler ComponentActivated; - event EventHandler ComponentAdded; - event EventHandler ComponentReloaded; - event EventHandler ComponentRemoved; - event EventHandler ComponentRenamed; - event EventHandler ComponentSelected; - } -} diff --git a/Rubberduck.VBEEditor/Events/Sinks.cs b/Rubberduck.VBEEditor/Events/Sinks.cs deleted file mode 100644 index e730cb13c9..0000000000 --- a/Rubberduck.VBEEditor/Events/Sinks.cs +++ /dev/null @@ -1,292 +0,0 @@ -using System; -using System.Collections.Generic; -using Rubberduck.VBEditor.SafeComWrappers; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; - -namespace Rubberduck.VBEditor.Events -{ - public class Sinks : ISinks, IDisposable - { - private readonly IVBE _vbe; - - private readonly ConnectionPointInfo _projectEventsInfo; - private IVBProjectsEventsSink _projectsSink; - - private readonly IDictionary _componentsEventsSinks = new Dictionary(); - private readonly IDictionary _componentEventsInfo = new Dictionary(); - - public bool ComponentSinksEnabled { get; set; } - - public Sinks(IVBE vbe) - { - _vbe = vbe; - _projectsSink = _vbe.VBProjects.Events; - _projectEventsInfo = new ConnectionPointInfo(_vbe.VBProjects.ConnectionPoint); - ComponentSinksEnabled = true; - } - - public void Start() - { - if (!_projectEventsInfo.HasConnectionPoint) { return; } - - _projectsSink.ProjectActivated += _sink_ProjectActivated; - _projectsSink.ProjectAdded += _sink_ProjectAdded; - _projectsSink.ProjectRemoved += _sink_ProjectRemoved; - _projectsSink.ProjectRenamed += _sink_ProjectRenamed; - _projectEventsInfo.Advise(_projectsSink); - foreach (var project in _vbe.VBProjects) - { - RegisterComponentsEventSink(project.VBComponents, project.ProjectId); - } - } - - public void Stop() - { - _projectsSink.ProjectActivated -= _sink_ProjectActivated; - _projectsSink.ProjectAdded -= _sink_ProjectAdded; - _projectsSink.ProjectRemoved -= _sink_ProjectRemoved; - _projectsSink.ProjectRenamed -= _sink_ProjectRenamed; - _projectEventsInfo.Unadvise(); - - foreach (var project in _vbe.VBProjects) - { - UnregisterComponentsEventSink(project.ProjectId); - } - } - - private void RegisterComponentsEventSink(IVBComponents components, string projectId) - { - if (projectId == null || _componentsEventsSinks.ContainsKey(projectId)) - { - // already registered - this is caused by the initial load+rename of a project in the VBE - return; - } - - var connectionPoint = components.ConnectionPoint; - var componentsSink = components.Events; - componentsSink.ComponentActivated += ComponentsSink_ComponentActivated; - componentsSink.ComponentAdded += ComponentsSink_ComponentAdded; - componentsSink.ComponentReloaded += ComponentsSink_ComponentReloaded; - componentsSink.ComponentRemoved += ComponentsSink_ComponentRemoved; - componentsSink.ComponentRenamed += ComponentsSink_ComponentRenamed; - componentsSink.ComponentSelected += ComponentsSink_ComponentSelected; - var info = new ConnectionPointInfo(connectionPoint); - info.Advise(componentsSink); - _componentEventsInfo.Add(projectId, info); - } - - private void UnregisterComponentsEventSink(string projectId) - { - if (projectId == null || !_componentsEventsSinks.ContainsKey(projectId)) { return; } - - var componentEventSink = _componentsEventsSinks[projectId]; - var info = _componentEventsInfo[projectId]; - info.Unadvise(); - componentEventSink.ComponentActivated -= ComponentsSink_ComponentActivated; - componentEventSink.ComponentAdded -= ComponentsSink_ComponentAdded; - componentEventSink.ComponentReloaded -= ComponentsSink_ComponentReloaded; - componentEventSink.ComponentRemoved -= ComponentsSink_ComponentRemoved; - componentEventSink.ComponentRenamed -= ComponentsSink_ComponentRenamed; - componentEventSink.ComponentSelected -= ComponentsSink_ComponentSelected; - _componentsEventsSinks.Remove(projectId); - _componentEventsInfo.Remove(projectId); - } - - #region ProjectEvents - - public event EventHandler ProjectActivated; - public event EventHandler ProjectAdded; - public event EventHandler ProjectRemoved; - public event EventHandler ProjectRenamed; - - private void _sink_ProjectActivated(object sender, DispatcherEventArgs e) - { - if (!_vbe.IsInDesignMode) { return; } - - var project = e.Item; - var projectId = project.ProjectId; - - var handler = ProjectActivated; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId, project)); - } - } - - private void _sink_ProjectAdded(object sender, DispatcherEventArgs e) - { - if (!_vbe.IsInDesignMode) { return; } - - var project = e.Item; - project.AssignProjectId(); - var projectId = project.ProjectId; - - RegisterComponentsEventSink(project.VBComponents, projectId); - - var handler = ProjectAdded; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId, project)); - } - } - - private void _sink_ProjectRemoved(object sender, DispatcherEventArgs e) - { - if (!_vbe.IsInDesignMode) { return; } - - var project = e.Item; - var projectId = project.ProjectId; - UnregisterComponentsEventSink(projectId); - - var handler = ProjectRemoved; - if (handler != null) - { - handler(sender, new ProjectEventArgs(projectId, project)); - } - - } - - private void _sink_ProjectRenamed(object sender, DispatcherRenamedEventArgs e) - { - if (!_vbe.IsInDesignMode) { return; } - - var project = e.Item; - var projectId = project.ProjectId; - var oldName = e.OldName; - - var handler = ProjectRenamed; - if (handler != null) - { - handler(sender, new ProjectRenamedEventArgs(projectId, project, oldName)); - } - - } - - #endregion - - #region ComponentEvents - public event EventHandler ComponentSelected; - public event EventHandler ComponentActivated; - public event EventHandler ComponentAdded; - public event EventHandler ComponentReloaded; - public event EventHandler ComponentRemoved; - public event EventHandler ComponentRenamed; - - private void ComponentsSink_ComponentActivated(object sender, DispatcherEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - - var projectId = project.ProjectId; - - var handler = ComponentActivated; - if (handler != null) - { - handler(sender, new ComponentEventArgs(projectId, project, component)); - } - - } - - private void ComponentsSink_ComponentAdded(object sender, DispatcherEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - - var projectId = project.ProjectId; - - var handler = ComponentAdded; - if (handler != null) - { - handler(sender, new ComponentEventArgs(projectId, project, component)); - } - - } - - private void ComponentsSink_ComponentReloaded(object sender, DispatcherEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - - var projectId = project.ProjectId; - - var handler = ComponentReloaded; - if (handler != null) - { - handler(sender, new ComponentEventArgs(projectId, project, component)); - } - - } - - private void ComponentsSink_ComponentRemoved(object sender, DispatcherEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - var projectId = project.ProjectId; - - var handler = ComponentRemoved; - if (handler != null) - { - handler(sender, new ComponentEventArgs(projectId, project, component)); - } - - } - - private void ComponentsSink_ComponentRenamed(object sender, DispatcherRenamedEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - var projectId = project.ProjectId; - - var handler = ComponentRenamed; - if (handler != null) - { - handler(sender, new ComponentRenamedEventArgs(projectId, project, component, e.OldName)); - } - - } - - private void ComponentsSink_ComponentSelected(object sender, DispatcherEventArgs e) - { - if (!ComponentSinksEnabled || !_vbe.IsInDesignMode) { return; } - - var component = e.Item; - var components = component.Collection; - var project = components.Parent; - - var projectId = project.ProjectId; - - var handler = ComponentSelected; - if (handler != null) - { - handler(sender, new ComponentEventArgs(projectId, project, component)); - } - - } - - #endregion - - public void Dispose() - { - if (_projectsSink != null) - { - Stop(); - _projectsSink = null; - } - } - } -} \ No newline at end of file diff --git a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj index fb24c607c5..0f086f1ba7 100644 --- a/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj +++ b/Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj @@ -122,14 +122,10 @@ - - - - @@ -177,11 +173,9 @@ - - @@ -220,11 +214,9 @@ - - @@ -237,7 +229,6 @@ - diff --git a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponents.cs b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponents.cs index 72e7a31630..b2510699a3 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponents.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponents.cs @@ -1,10 +1,18 @@ using System; using System.Runtime.InteropServices.ComTypes; +using Rubberduck.VBEditor.Events; namespace Rubberduck.VBEditor.SafeComWrappers.Abstract { public interface IVBComponents : ISafeComWrapper, IComCollection, IEquatable { + event EventHandler ComponentAdded; + event EventHandler ComponentRemoved; + event EventHandler ComponentRenamed; + event EventHandler ComponentSelected; + event EventHandler ComponentActivated; + event EventHandler ComponentReloaded; + new IVBComponent this[object index] { get; } IVBE VBE { get; } @@ -16,8 +24,5 @@ public interface IVBComponents : ISafeComWrapper, IComCollection, IVBComponent AddMTDesigner(int index = 0); void ImportSourceFile(string path); void RemoveSafely(IVBComponent component); - - IVBComponentsEventsSink Events { get; } - IConnectionPoint ConnectionPoint { get; } } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponentsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponentsEventsSink.cs deleted file mode 100644 index 32a6ac9786..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBComponentsEventsSink.cs +++ /dev/null @@ -1,14 +0,0 @@ -using System; - -namespace Rubberduck.VBEditor.SafeComWrappers.Abstract -{ - public interface IVBComponentsEventsSink - { - event EventHandler> ComponentAdded; - event EventHandler> ComponentRemoved; - event EventHandler> ComponentRenamed; - event EventHandler> ComponentSelected; - event EventHandler> ComponentActivated; - event EventHandler> ComponentReloaded; - } -} \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBE.cs b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBE.cs index 7dabbc6117..0478864e60 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBE.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBE.cs @@ -8,6 +8,7 @@ namespace Rubberduck.VBEditor.SafeComWrappers.Abstract public interface IVBE : ISafeComWrapper, IEquatable { string Version { get; } + object HardReference { get; } IWindow ActiveWindow { get; } ICodePane ActiveCodePane { get; set; } IVBProject ActiveVBProject { get; set; } diff --git a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjects.cs b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjects.cs index f1cdc19942..0c6b78e89b 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjects.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjects.cs @@ -1,17 +1,20 @@ using System; using System.Runtime.InteropServices.ComTypes; +using Rubberduck.VBEditor.Events; namespace Rubberduck.VBEditor.SafeComWrappers.Abstract { public interface IVBProjects : ISafeComWrapper, IComCollection, IEquatable { + event EventHandler ProjectActivated; + event EventHandler ProjectAdded; + event EventHandler ProjectRemoved; + event EventHandler ProjectRenamed; + IVBE VBE { get; } IVBE Parent { get; } IVBProject Add(ProjectType type); IVBProject Open(string path); void Remove(IVBProject project); - - IVBProjectsEventsSink Events { get; } - IConnectionPoint ConnectionPoint { get; } } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjectsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjectsEventsSink.cs deleted file mode 100644 index b40c9f35f9..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/Abstract/IVBProjectsEventsSink.cs +++ /dev/null @@ -1,12 +0,0 @@ -using System; - -namespace Rubberduck.VBEditor.SafeComWrappers.Abstract -{ - public interface IVBProjectsEventsSink - { - event EventHandler> ProjectAdded; - event EventHandler> ProjectRemoved; - event EventHandler> ProjectRenamed; - event EventHandler> ProjectActivated; - } -} \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/CodeModule.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/CodeModule.cs index abb81a8a3e..e6c3866da4 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/CodeModule.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VB6/CodeModule.cs @@ -128,7 +128,7 @@ private void StripLineNumbers(string[] lines) } } - continuing = code.EndsWith("_"); + continuing = code.EndsWith(" _"); } } diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponents.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponents.cs index 56a25dc154..30a03a7985 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponents.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponents.cs @@ -3,7 +3,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; -using System.Runtime.InteropServices.ComTypes; +using System.Runtime.InteropServices; +using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.Extensions; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using VB = Microsoft.VB6.Interop.VBIDE; @@ -12,12 +13,24 @@ namespace Rubberduck.VBEditor.SafeComWrappers.VB6 { public class VBComponents : SafeComWrapper, IVBComponents { - private readonly IVBComponentsEventsSink _sink; + //TODO - This is currently the VBA Guid, and it need to be updated when VB6 support is added. + private static readonly Guid VBComponentsEventsGuid = new Guid("0002E116-0000-0000-C000-000000000046"); - public VBComponents(VB.VBComponents target) + //TODO - These *should* be the same, but this should be verified. + private enum ComponentEventDispId + { + ItemAdded = 1, + ItemRemoved = 2, + ItemRenamed = 3, + ItemSelected = 4, + ItemActivated = 5, + ItemReloaded = 6 + } + + public VBComponents(VB.VBComponents target) : base(target) { - _sink = new VBComponentsEventsSink(); + AttachEvents(); } public int Count @@ -42,46 +55,51 @@ public IVBComponent this[object index] public void Remove(IVBComponent item) { - Target.Remove((VB.VBComponent)item.Target); + if (item != null && item.Target != null && !IsWrappingNullReference) + { + Target.Remove((VB.VBComponent)item.Target); + } } public IVBComponent Add(ComponentType type) { - return new VBComponent(Target.Add((VB.vbext_ComponentType)type)); + return new VBComponent(IsWrappingNullReference ? null : Target.Add((VB.vbext_ComponentType)type)); } public IVBComponent Import(string path) { throw new NotImplementedException(); - //return new VBComponent((VB.VBComponent)Target.Import(path).Target); } public IVBComponent AddCustom(string progId) { - throw new NotImplementedException(); - //return new VBComponent((VB.VBComponent)Target.AddCustom(progId).Target); + return new VBComponent(IsWrappingNullReference ? null : Target.AddCustom(progId)); } public IVBComponent AddMTDesigner(int index = 0) { throw new NotImplementedException(); - //return new VBComponent((VB.VBComponent)Target.AddMTDesigner(index).Target); } IEnumerator IEnumerable.GetEnumerator() { - return new ComWrapperEnumerator(Target, o => new VBComponent((VB.VBComponent)o)); + return IsWrappingNullReference + ? new ComWrapperEnumerator(null, o => new VBComponent(null)) + : new ComWrapperEnumerator(Target, o => new VBComponent((VB.VBComponent)o)); } IEnumerator IEnumerable.GetEnumerator() { - return ((IEnumerable)this).GetEnumerator(); + return IsWrappingNullReference + ? (IEnumerator)new List().GetEnumerator() + : ((IEnumerable)this).GetEnumerator(); } public override void Release(bool final = false) { if (!IsWrappingNullReference) { + DetatchEvents(); for (var i = 1; i <= Count; i++) { this[i].Release(); @@ -119,17 +137,17 @@ public void ImportSourceFile(string path) if (ext == ComponentTypeExtensions.DocClassExtension) { var component = this[name]; + if (component.IsWrappingNullReference) + { + throw new IndexOutOfRangeException(string.Format("Could not find document component named '{0}'.", name)); + } component.CodeModule.Clear(); component.CodeModule.AddFromString(codeString); } else if (ext == ComponentTypeExtensions.FormExtension) { - IVBComponent component; - try - { - component = this[name]; - } - catch + var component = this[name]; + if (component.IsWrappingNullReference) { component = Add(ComponentType.UserForm); component.Properties["Caption"].Value = name; @@ -175,27 +193,105 @@ public void RemoveSafely(IVBComponent component) } } - public IVBComponentsEventsSink Events { get { return _sink; } } + #region Events - public IConnectionPoint ConnectionPoint + private bool _eventsAttached; + private void AttachEvents() { - get + throw new NotImplementedException("Correct the Guid (see comment above), verify the DispIds, then remove this throw."); + if (!_eventsAttached && !IsWrappingNullReference) { - try - { - // ReSharper disable once SuspiciousTypeConversion.Global - var connectionPointContainer = (IConnectionPointContainer)Target; - var interfaceId = typeof(VB._dispVBComponentsEvents).GUID; - IConnectionPoint result; - connectionPointContainer.FindConnectionPoint(ref interfaceId, out result); - return result; - } - catch (Exception) - { - return null; - } + _componentAdded = OnComponentAdded; + _componentRemoved = OnComponentRemoved; + _componentRenamed = OnComponentRenamed; + _componentSelected = OnComponentSelected; + _componentActivated = OnComponentActivated; + _componentReloaded = OnComponentReloaded; + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemAdded, _componentAdded); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRemoved, _componentRemoved); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRenamed, _componentRenamed); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemSelected, _componentSelected); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemActivated, _componentActivated); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemReloaded, _componentReloaded); + _eventsAttached = true; + } + } + private void DetatchEvents() + { + if (!_eventsAttached && !IsWrappingNullReference) + { + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemAdded, _componentAdded); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRemoved, _componentRemoved); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRenamed, _componentRenamed); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemSelected, _componentSelected); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemActivated, _componentActivated); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemReloaded, _componentReloaded); + _eventsAttached = false; } } + + private delegate void ItemAddedDelegate(VB.VBComponent vbComponent); + private ItemAddedDelegate _componentAdded; + public event EventHandler ComponentAdded; + private void OnComponentAdded(VB.VBComponent vbComponent) + { + OnDispatch(ComponentAdded, vbComponent); + } + + private delegate void ItemRemovedDelegate(VB.VBComponent vbComponent); + private ItemRemovedDelegate _componentRemoved; + public event EventHandler ComponentRemoved; + private void OnComponentRemoved(VB.VBComponent vbComponent) + { + OnDispatch(ComponentRemoved, vbComponent); + } + + private delegate void ItemRenamedDelegate(VB.VBComponent vbComponent, string oldName); + private ItemRenamedDelegate _componentRenamed; + public event EventHandler ComponentRenamed; + private void OnComponentRenamed(VB.VBComponent vbComponent, string oldName) + { + var handler = ComponentRenamed; + if (handler != null) + { + handler.Invoke(this, new ComponentRenamedEventArgs(Parent.ProjectId, Parent, new VBComponent(vbComponent), oldName)); + } + } + + private delegate void ItemSelectedDelegate(VB.VBComponent vbComponent); + private ItemSelectedDelegate _componentSelected; + public event EventHandler ComponentSelected; + private void OnComponentSelected(VB.VBComponent vbComponent) + { + OnDispatch(ComponentSelected, vbComponent); + } + + private delegate void ItemActivatedDelegate(VB.VBComponent vbComponent); + private ItemActivatedDelegate _componentActivated; + public event EventHandler ComponentActivated; + private void OnComponentActivated(VB.VBComponent vbComponent) + { + OnDispatch(ComponentActivated, vbComponent); + } + + private delegate void ItemReloadedDelegate(VB.VBComponent vbComponent); + private ItemReloadedDelegate _componentReloaded; + public event EventHandler ComponentReloaded; + private void OnComponentReloaded(VB.VBComponent vbComponent) + { + OnDispatch(ComponentReloaded, vbComponent); + } + + private void OnDispatch(EventHandler dispatched, VB.VBComponent component) + { + var handler = dispatched; + if (handler != null) + { + handler.Invoke(this, new ComponentEventArgs(Parent.ProjectId, Parent, new VBComponent(component))); + } + } + + #endregion } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponentsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponentsEventsSink.cs deleted file mode 100644 index 0094f2e663..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBComponentsEventsSink.cs +++ /dev/null @@ -1,60 +0,0 @@ -using System; -using System.Diagnostics.CodeAnalysis; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using VB = Microsoft.VB6.Interop.VBIDE; - -namespace Rubberduck.VBEditor.SafeComWrappers.VB6 -{ - [SuppressMessage("ReSharper", "InconsistentNaming")] - public class VBComponentsEventsSink : VB._dispVBComponentsEvents, IVBComponentsEventsSink - { - public event EventHandler> ComponentAdded; - public void ItemAdded(VB.VBComponent VBComponent) - { - OnDispatch(ComponentAdded, VBComponent); - } - - public event EventHandler> ComponentRemoved; - public void ItemRemoved(VB.VBComponent VBComponent) - { - OnDispatch(ComponentRemoved, VBComponent); - } - - public event EventHandler> ComponentRenamed; - public void ItemRenamed(VB.VBComponent VBComponent, string OldName) - { - var handler = ComponentRenamed; - if (handler != null) - { - handler.Invoke(this, new DispatcherRenamedEventArgs(new VBComponent(VBComponent), OldName)); - } - } - - public event EventHandler> ComponentSelected; - public void ItemSelected(VB.VBComponent VBComponent) - { - OnDispatch(ComponentSelected, VBComponent); - } - - public event EventHandler> ComponentActivated; - public void ItemActivated(VB.VBComponent VBComponent) - { - OnDispatch(ComponentActivated, VBComponent); - } - - public event EventHandler> ComponentReloaded; - public void ItemReloaded(VB.VBComponent VBComponent) - { - OnDispatch(ComponentReloaded, VBComponent); - } - - private void OnDispatch(EventHandler> dispatched, VB.VBComponent component) - { - var handler = dispatched; - if (handler != null) - { - handler.Invoke(this, new DispatcherEventArgs(new VBComponent(component))); - } - } - } -} diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBE.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBE.cs index 80a4c3029b..10515004fd 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBE.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBE.cs @@ -14,6 +14,11 @@ public VBE(VB.VBE target) { } + public object HardReference + { + get { return Target; } + } + public string Version { get { return IsWrappingNullReference ? string.Empty : Target.get_Version(); } diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjects.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjects.cs index 219e6a2ce6..02c4cc0fcc 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjects.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjects.cs @@ -1,7 +1,9 @@ using System; using System.Collections; using System.Collections.Generic; +using System.Runtime.InteropServices; using System.Runtime.InteropServices.ComTypes; +using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using VB = Microsoft.VB6.Interop.VBIDE; @@ -9,12 +11,21 @@ namespace Rubberduck.VBEditor.SafeComWrappers.VB6 { public class VBProjects : SafeComWrapper, IVBProjects { - private readonly IVBProjectsEventsSink _sink; + //TODO - This is currently the VBA Guid, and it need to be updated when VB6 support is added. + private static readonly Guid VBProjectsEventsGuid = new Guid("0002E103-0000-0000-C000-000000000046"); - public VBProjects(VB.VBProjects target) - : base(target) + //TODO - These *should* be the same, but this should be verified. + private enum ProjectEventDispId { - _sink = new VBProjectsEventsSink(); + ItemAdded = 1, + ItemRemoved = 2, + ItemRenamed = 3, + ItemActivated = 4 + } + + public VBProjects(VB.VBProjects target) : base(target) + { + AttachEvents(); } public int Count @@ -34,59 +45,44 @@ public IVBE Parent public IVBProject Add(ProjectType type) { - return new VBProject(Target.Add((VB.vbext_ProjectType)type)); - } - - public IVBProject Open(string path) - { - throw new NotImplementedException(); + return new VBProject(IsWrappingNullReference ? null : Target.Add((VB.vbext_ProjectType)type)); } public void Remove(IVBProject project) { + if (IsWrappingNullReference) return; Target.Remove((VB.VBProject)project.Target); } - public IVBProjectsEventsSink Events { get { return _sink; } } - - public IConnectionPoint ConnectionPoint + public IVBProject Open(string path) { - get - { - try - { - var connectionPointContainer = (IConnectionPointContainer)Target; - var interfaceId = typeof(VB._dispVBProjectsEvents).GUID; - IConnectionPoint result; - connectionPointContainer.FindConnectionPoint(ref interfaceId, out result); - return result; - } - catch (Exception) - { - return null; - } - } + throw new NotImplementedException(); } public IVBProject this[object index] { - get { return new VBProject(Target.Item(index)); } + get { return new VBProject(IsWrappingNullReference ? null : Target.Item(index)); } } IEnumerator IEnumerable.GetEnumerator() { - return new ComWrapperEnumerator(Target, o => new VBProject((VB.VBProject)o)); + return IsWrappingNullReference + ? new ComWrapperEnumerator(null, o => new VBProject(null)) + : new ComWrapperEnumerator(Target, o => new VBProject((VB.VBProject)o)); } IEnumerator IEnumerable.GetEnumerator() { - return ((IEnumerable)this).GetEnumerator(); + return IsWrappingNullReference + ? (IEnumerator)new List().GetEnumerator() + : ((IEnumerable)this).GetEnumerator(); } public override void Release(bool final = false) { if (!IsWrappingNullReference) { + DetatchEvents(); for (var i = 1; i <= Count; i++) { this[i].Release(); @@ -107,8 +103,97 @@ public bool Equals(IVBProjects other) public override int GetHashCode() { - return IsWrappingNullReference ? 0 + return IsWrappingNullReference ? 0 : HashCode.Compute(Target); } + + #region Events + + private bool _eventsAttached; + private void AttachEvents() + { + throw new NotImplementedException("Correct the Guid (see comment above), verify the DispIds, then remove this throw."); + if (!_eventsAttached && !IsWrappingNullReference) + { + _projectAdded = OnProjectAdded; + _projectRemoved = OnProjectRemoved; + _projectRenamed = OnProjectRenamed; + _projectActivated = OnProjectActivated; + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemAdded, _projectAdded); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRemoved, _projectRemoved); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRenamed, _projectRenamed); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemActivated, _projectActivated); + } + } + + private void DetatchEvents() + { + if (!_eventsAttached && !IsWrappingNullReference) + { + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemAdded, _projectAdded); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRemoved, _projectRemoved); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRenamed, _projectRenamed); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemActivated, _projectActivated); + _eventsAttached = false; + } + } + + public event EventHandler ProjectAdded; + private delegate void ItemAddedDelegate(Microsoft.Vbe.Interop.VBProject vbProject); + private ItemAddedDelegate _projectAdded; + private void OnProjectAdded(Microsoft.Vbe.Interop.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectAdded, vbProject, true); + } + + public event EventHandler ProjectRemoved; + private delegate void ItemRemovedDelegate(Microsoft.Vbe.Interop.VBProject vbProject); + private ItemRemovedDelegate _projectRemoved; + private void OnProjectRemoved(Microsoft.Vbe.Interop.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectRemoved, vbProject); + } + + public event EventHandler ProjectRenamed; + private delegate void ItemRenamedDelegate(Microsoft.Vbe.Interop.VBProject vbProject, string oldName); + private ItemRenamedDelegate _projectRenamed; + private void OnProjectRenamed(Microsoft.Vbe.Interop.VBProject vbProject, string oldName) + { + if (!VBE.IsInDesignMode) { return; } + + var project = new VBA.VBProject(vbProject); + var projectId = project.ProjectId; + + var handler = ProjectRenamed; + if (handler != null) + { + handler(this, new ProjectRenamedEventArgs(projectId, project, oldName)); + } + } + + public event EventHandler ProjectActivated; + private delegate void ItemActivatedDelegate(Microsoft.Vbe.Interop.VBProject vbProject); + private ItemActivatedDelegate _projectActivated; + private void OnProjectActivated(Microsoft.Vbe.Interop.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectActivated, vbProject); + } + + private void OnDispatch(EventHandler dispatched, Microsoft.Vbe.Interop.VBProject vbProject, bool assignId = false) + { + var handler = dispatched; + if (handler != null) + { + var project = new VBA.VBProject(vbProject); + if (assignId) + { + project.AssignProjectId(); + } + var projectId = project.ProjectId; + handler.Invoke(this, new ProjectEventArgs(projectId, project)); + } + } + + #endregion } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjectsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjectsEventsSink.cs deleted file mode 100644 index 8ddf61bdab..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/VB6/VBProjectsEventsSink.cs +++ /dev/null @@ -1,48 +0,0 @@ -using System; -using System.Diagnostics.CodeAnalysis; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using VB = Microsoft.VB6.Interop.VBIDE; - -namespace Rubberduck.VBEditor.SafeComWrappers.VB6 -{ - [SuppressMessage("ReSharper", "InconsistentNaming")] - public class VBProjectsEventsSink : VB._dispVBProjectsEvents, IVBProjectsEventsSink - { - public event EventHandler> ProjectAdded; - public void ItemAdded(VB.VBProject VBProject) - { - OnDispatch(ProjectAdded, VBProject); - } - - public event EventHandler> ProjectRemoved; - public void ItemRemoved(VB.VBProject VBProject) - { - OnDispatch(ProjectRemoved, VBProject); - } - - public event EventHandler> ProjectRenamed; - public void ItemRenamed(VB.VBProject VBProject, string OldName) - { - var handler = ProjectRenamed; - if (handler != null) - { - handler.Invoke(this, new DispatcherRenamedEventArgs(new VBProject(VBProject), OldName)); - } - } - - public event EventHandler> ProjectActivated; - public void ItemActivated(VB.VBProject VBProject) - { - OnDispatch(ProjectActivated, VBProject); - } - - private void OnDispatch(EventHandler> dispatched, VB.VBProject project) - { - var handler = dispatched; - if (handler != null) - { - handler.Invoke(this, new DispatcherEventArgs(new VBProject(project))); - } - } - } -} diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponent.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponent.cs index d632b50c1e..a7f008049d 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponent.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponent.cs @@ -131,10 +131,7 @@ public string ExportAsSourceFile(string folder) public IVBProject ParentProject { - get - { - return Collection != null ? Collection.Parent : null; - } + get { return Collection.Parent; } } private void ExportUserFormModule(string path) diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponents.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponents.cs index 17a0ecfa28..d7acc70165 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponents.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponents.cs @@ -3,7 +3,8 @@ using System.Collections.Generic; using System.IO; using System.Linq; -using System.Runtime.InteropServices.ComTypes; +using System.Runtime.InteropServices; +using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.Extensions; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using VB = Microsoft.Vbe.Interop; @@ -12,12 +13,21 @@ namespace Rubberduck.VBEditor.SafeComWrappers.VBA { public class VBComponents : SafeComWrapper, IVBComponents { - private readonly IVBComponentsEventsSink _sink; + private static readonly Guid VBComponentsEventsGuid = new Guid("0002E116-0000-0000-C000-000000000046"); - public VBComponents(VB.VBComponents target) - : base(target) + private enum ComponentEventDispId { - _sink = new VBComponentsEventsSink(); + ItemAdded = 1, + ItemRemoved = 2, + ItemRenamed = 3, + ItemSelected = 4, + ItemActivated = 5, + ItemReloaded = 6 + } + + public VBComponents(VB.VBComponents target) : base(target) + { + AttachEvents(); } public int Count @@ -42,7 +52,10 @@ public IVBComponent this[object index] public void Remove(IVBComponent item) { - if (!IsWrappingNullReference) Target.Remove((VB.VBComponent)item.Target); + if (item != null && item.Target != null && !IsWrappingNullReference) + { + Target.Remove((VB.VBComponent)item.Target); + } } public IVBComponent Add(ComponentType type) @@ -83,6 +96,7 @@ public override void Release(bool final = false) { if (!IsWrappingNullReference) { + DetatchEvents(); for (var i = 1; i <= Count; i++) { this[i].Release(); @@ -176,27 +190,104 @@ public void RemoveSafely(IVBComponent component) } } - public IVBComponentsEventsSink Events { get { return _sink; } } + #region Events - public IConnectionPoint ConnectionPoint + private bool _eventsAttached; + private void AttachEvents() { - get + if (!_eventsAttached && !IsWrappingNullReference) { - try - { - // ReSharper disable once SuspiciousTypeConversion.Global - var connectionPointContainer = (IConnectionPointContainer)Target; - var interfaceId = typeof(VB._dispVBComponentsEvents).GUID; - IConnectionPoint result; - connectionPointContainer.FindConnectionPoint(ref interfaceId, out result); - return result; - } - catch (Exception) - { - return null; - } + _componentAdded = OnComponentAdded; + _componentRemoved = OnComponentRemoved; + _componentRenamed = OnComponentRenamed; + _componentSelected = OnComponentSelected; + _componentActivated = OnComponentActivated; + _componentReloaded = OnComponentReloaded; + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemAdded, _componentAdded); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRemoved, _componentRemoved); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRenamed, _componentRenamed); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemSelected, _componentSelected); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemActivated, _componentActivated); + ComEventsHelper.Combine(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemReloaded, _componentReloaded); + _eventsAttached = true; + } + } + private void DetatchEvents() + { + if (!_eventsAttached && !IsWrappingNullReference) + { + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemAdded, _componentAdded); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRemoved, _componentRemoved); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemRenamed, _componentRenamed); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemSelected, _componentSelected); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemActivated, _componentActivated); + ComEventsHelper.Remove(Target, VBComponentsEventsGuid, (int)ComponentEventDispId.ItemReloaded, _componentReloaded); + _eventsAttached = false; } } + + private delegate void ItemAddedDelegate(VB.VBComponent vbComponent); + private ItemAddedDelegate _componentAdded; + public event EventHandler ComponentAdded; + private void OnComponentAdded(VB.VBComponent vbComponent) + { + OnDispatch(ComponentAdded, vbComponent); + } + + private delegate void ItemRemovedDelegate(VB.VBComponent vbComponent); + private ItemRemovedDelegate _componentRemoved; + public event EventHandler ComponentRemoved; + private void OnComponentRemoved(VB.VBComponent vbComponent) + { + OnDispatch(ComponentRemoved, vbComponent); + } + + private delegate void ItemRenamedDelegate(VB.VBComponent vbComponent, string oldName); + private ItemRenamedDelegate _componentRenamed; + public event EventHandler ComponentRenamed; + private void OnComponentRenamed(VB.VBComponent vbComponent, string oldName) + { + var handler = ComponentRenamed; + if (handler != null) + { + handler.Invoke(this, new ComponentRenamedEventArgs(Parent.ProjectId, Parent, new VBComponent(vbComponent), oldName)); + } + } + + private delegate void ItemSelectedDelegate(VB.VBComponent vbComponent); + private ItemSelectedDelegate _componentSelected; + public event EventHandler ComponentSelected; + private void OnComponentSelected(VB.VBComponent vbComponent) + { + OnDispatch(ComponentSelected, vbComponent); + } + + private delegate void ItemActivatedDelegate(VB.VBComponent vbComponent); + private ItemActivatedDelegate _componentActivated; + public event EventHandler ComponentActivated; + private void OnComponentActivated(VB.VBComponent vbComponent) + { + OnDispatch(ComponentActivated, vbComponent); + } + + private delegate void ItemReloadedDelegate(VB.VBComponent vbComponent); + private ItemReloadedDelegate _componentReloaded; + public event EventHandler ComponentReloaded; + private void OnComponentReloaded(VB.VBComponent vbComponent) + { + OnDispatch(ComponentReloaded, vbComponent); + } + + private void OnDispatch(EventHandler dispatched, VB.VBComponent component) + { + var handler = dispatched; + if (handler != null) + { + handler.Invoke(this, new ComponentEventArgs(Parent.ProjectId, Parent, new VBComponent(component))); + } + } + + #endregion } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponentsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponentsEventsSink.cs deleted file mode 100644 index f174668243..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBComponentsEventsSink.cs +++ /dev/null @@ -1,60 +0,0 @@ -using System; -using System.Diagnostics.CodeAnalysis; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using VB = Microsoft.Vbe.Interop; - -namespace Rubberduck.VBEditor.SafeComWrappers.VBA -{ - [SuppressMessage("ReSharper", "InconsistentNaming")] - public class VBComponentsEventsSink : VB._dispVBComponentsEvents, IVBComponentsEventsSink - { - public event EventHandler> ComponentAdded; - public void ItemAdded(VB.VBComponent VBComponent) - { - OnDispatch(ComponentAdded, VBComponent); - } - - public event EventHandler> ComponentRemoved; - public void ItemRemoved(VB.VBComponent VBComponent) - { - OnDispatch(ComponentRemoved, VBComponent); - } - - public event EventHandler> ComponentRenamed; - public void ItemRenamed(VB.VBComponent VBComponent, string OldName) - { - var handler = ComponentRenamed; - if (handler != null) - { - handler.Invoke(this, new DispatcherRenamedEventArgs(new VBComponent(VBComponent), OldName)); - } - } - - public event EventHandler> ComponentSelected; - public void ItemSelected(VB.VBComponent VBComponent) - { - OnDispatch(ComponentSelected, VBComponent); - } - - public event EventHandler> ComponentActivated; - public void ItemActivated(VB.VBComponent VBComponent) - { - OnDispatch(ComponentActivated, VBComponent); - } - - public event EventHandler> ComponentReloaded; - public void ItemReloaded(VB.VBComponent VBComponent) - { - OnDispatch(ComponentReloaded, VBComponent); - } - - private void OnDispatch(EventHandler> dispatched, VB.VBComponent component) - { - var handler = dispatched; - if (handler != null) - { - handler.Invoke(this, new DispatcherEventArgs(new VBComponent(component))); - } - } - } -} diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBE.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBE.cs index 951d2ae403..57fef9c3ea 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBE.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBE.cs @@ -19,6 +19,11 @@ public VBE(VB.VBE target) { } + public object HardReference + { + get { return Target; } + } + public string Version { get { return IsWrappingNullReference ? string.Empty : Target.Version; } diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjects.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjects.cs index 4c39d42247..4dfe0fc17f 100644 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjects.cs +++ b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjects.cs @@ -1,7 +1,8 @@ using System; using System.Collections; using System.Collections.Generic; -using System.Runtime.InteropServices.ComTypes; +using System.Runtime.InteropServices; +using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using VB = Microsoft.Vbe.Interop; @@ -9,12 +10,19 @@ namespace Rubberduck.VBEditor.SafeComWrappers.VBA { public class VBProjects : SafeComWrapper, IVBProjects { - private readonly IVBProjectsEventsSink _sink; + private static readonly Guid VBProjectsEventsGuid = new Guid("0002E103-0000-0000-C000-000000000046"); - public VBProjects(VB.VBProjects target) - : base(target) + private enum ProjectEventDispId { - _sink = new VBProjectsEventsSink(); + ItemAdded = 1, + ItemRemoved = 2, + ItemRenamed = 3, + ItemActivated = 4 + } + + public VBProjects(VB.VBProjects target) : base(target) + { + AttachEvents(); } public int Count @@ -43,27 +51,6 @@ public void Remove(IVBProject project) Target.Remove((VB.VBProject) project.Target); } - public IVBProjectsEventsSink Events { get { return _sink; } } - - public IConnectionPoint ConnectionPoint - { - get - { - try - { - var connectionPointContainer = (IConnectionPointContainer)Target; - var interfaceId = typeof(VB._dispVBProjectsEvents).GUID; - IConnectionPoint result; - connectionPointContainer.FindConnectionPoint(ref interfaceId, out result); - return result; - } - catch (Exception) - { - return null; - } - } - } - public IVBProject Open(string path) { return new VBProject(IsWrappingNullReference ? null : Target.Open(path)); @@ -92,6 +79,7 @@ public override void Release(bool final = false) { if (!IsWrappingNullReference) { + DetatchEvents(); for (var i = 1; i <= Count; i++) { this[i].Release(); @@ -115,5 +103,93 @@ public override int GetHashCode() return IsWrappingNullReference ? 0 : HashCode.Compute(Target); } + + #region Events + + private bool _eventsAttached; + private void AttachEvents() + { + if (!_eventsAttached && !IsWrappingNullReference) + { + _projectAdded = OnProjectAdded; + _projectRemoved = OnProjectRemoved; + _projectRenamed = OnProjectRenamed; + _projectActivated = OnProjectActivated; + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemAdded, _projectAdded); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRemoved, _projectRemoved); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRenamed, _projectRenamed); + ComEventsHelper.Combine(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemActivated, _projectActivated); + } + } + + private void DetatchEvents() + { + if (!_eventsAttached && !IsWrappingNullReference) + { + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemAdded, _projectAdded); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRemoved, _projectRemoved); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemRenamed, _projectRenamed); + ComEventsHelper.Remove(Target, VBProjectsEventsGuid, (int)ProjectEventDispId.ItemActivated, _projectActivated); + _eventsAttached = false; + } + } + + public event EventHandler ProjectAdded; + private delegate void ItemAddedDelegate(VB.VBProject vbProject); + private ItemAddedDelegate _projectAdded; + private void OnProjectAdded(VB.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectAdded, vbProject, true); + } + + public event EventHandler ProjectRemoved; + private delegate void ItemRemovedDelegate(VB.VBProject vbProject); + private ItemRemovedDelegate _projectRemoved; + private void OnProjectRemoved(VB.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectRemoved, vbProject); + } + + public event EventHandler ProjectRenamed; + private delegate void ItemRenamedDelegate(VB.VBProject vbProject, string oldName); + private ItemRenamedDelegate _projectRenamed; + private void OnProjectRenamed(VB.VBProject vbProject, string oldName) + { + if (!VBE.IsInDesignMode) { return; } + + var project = new VBProject(vbProject); + var projectId = project.ProjectId; + + var handler = ProjectRenamed; + if (handler != null) + { + handler(this, new ProjectRenamedEventArgs(projectId, project, oldName)); + } + } + + public event EventHandler ProjectActivated; + private delegate void ItemActivatedDelegate(VB.VBProject vbProject); + private ItemActivatedDelegate _projectActivated; + private void OnProjectActivated(VB.VBProject vbProject) + { + if (VBE.IsInDesignMode) OnDispatch(ProjectActivated, vbProject); + } + + private void OnDispatch(EventHandler dispatched, VB.VBProject vbProject, bool assignId = false) + { + var handler = dispatched; + if (handler != null) + { + var project = new VBProject(vbProject); + if (assignId) + { + project.AssignProjectId(); + } + var projectId = project.ProjectId; + handler.Invoke(this, new ProjectEventArgs(projectId, project)); + } + } + + #endregion } } \ No newline at end of file diff --git a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjectsEventsSink.cs b/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjectsEventsSink.cs deleted file mode 100644 index d484e4cb0f..0000000000 --- a/Rubberduck.VBEEditor/SafeComWrappers/VBA/VBProjectsEventsSink.cs +++ /dev/null @@ -1,48 +0,0 @@ -using System; -using System.Diagnostics.CodeAnalysis; -using Rubberduck.VBEditor.SafeComWrappers.Abstract; -using VB = Microsoft.Vbe.Interop; - -namespace Rubberduck.VBEditor.SafeComWrappers.VBA -{ - [SuppressMessage("ReSharper", "InconsistentNaming")] - public class VBProjectsEventsSink : VB._dispVBProjectsEvents, IVBProjectsEventsSink - { - public event EventHandler> ProjectAdded; - public void ItemAdded(VB.VBProject VBProject) - { - OnDispatch(ProjectAdded, VBProject); - } - - public event EventHandler> ProjectRemoved; - public void ItemRemoved(VB.VBProject VBProject) - { - OnDispatch(ProjectRemoved, VBProject); - } - - public event EventHandler> ProjectRenamed; - public void ItemRenamed(VB.VBProject VBProject, string OldName) - { - var handler = ProjectRenamed; - if (handler != null && VBProject.Protection == VB.vbext_ProjectProtection.vbext_pp_none) - { - handler.Invoke(this, new DispatcherRenamedEventArgs(new VBProject(VBProject), OldName)); - } - } - - public event EventHandler> ProjectActivated; - public void ItemActivated(VB.VBProject VBProject) - { - OnDispatch(ProjectActivated, VBProject); - } - - private void OnDispatch(EventHandler> dispatched, VB.VBProject project) - { - var handler = dispatched; - if (handler != null && project.Protection == VB.vbext_ProjectProtection.vbext_pp_none) - { - handler.Invoke(this, new DispatcherEventArgs(new VBProject(project))); - } - } - } -} diff --git a/Rubberduck.VBEEditor/SubClassingWindowEventArgs.cs b/Rubberduck.VBEEditor/SubClassingWindowEventArgs.cs index de405fc819..dd15234a91 100644 --- a/Rubberduck.VBEEditor/SubClassingWindowEventArgs.cs +++ b/Rubberduck.VBEEditor/SubClassingWindowEventArgs.cs @@ -5,16 +5,18 @@ namespace Rubberduck.VBEditor { public class SubClassingWindowEventArgs : EventArgs { - private readonly Message _msg; + private readonly IntPtr _lparam; - public Message Message + public IntPtr LParam { - get { return _msg; } + get { return _lparam; } } - public SubClassingWindowEventArgs(Message msg) + public bool Closing { get; set; } + + public SubClassingWindowEventArgs(IntPtr lparam) { - _msg = msg; + _lparam = lparam; } } -} +} \ No newline at end of file diff --git a/Rubberduck.sln b/Rubberduck.sln index 4ad9685899..7d5c09aad7 100644 --- a/Rubberduck.sln +++ b/Rubberduck.sln @@ -254,7 +254,4 @@ Global GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection - GlobalSection(Performance) = preSolution - HasPerformanceSessions = true - EndGlobalSection EndGlobal diff --git a/RubberduckTests/Binding/IndexDefaultBindingTests.cs b/RubberduckTests/Binding/IndexDefaultBindingTests.cs index 4ec1a1ad9d..f686103fbe 100644 --- a/RubberduckTests/Binding/IndexDefaultBindingTests.cs +++ b/RubberduckTests/Binding/IndexDefaultBindingTests.cs @@ -87,7 +87,7 @@ End Property private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs b/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs index 732385c074..6d526fa27b 100644 --- a/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessDefaultBindingTests.cs @@ -96,7 +96,7 @@ public void LExpressionIsEnum() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs b/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs index 6f7cb8b151..4e5a4685c8 100644 --- a/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessProcedurePointerBindingTests.cs @@ -41,7 +41,7 @@ public void ProceduralModuleWithAccessibleMember() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs b/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs index 1af9b2a6dc..c917173afa 100644 --- a/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs +++ b/RubberduckTests/Binding/MemberAccessTypeBindingTests.cs @@ -148,6 +148,8 @@ public void NestedMemberAccessExpressions() var vbe = builder.Build(); var state = Parse(vbe); + Assert.AreEqual(state.Status, ParserState.Ready); + var declaration = state.AllUserDeclarations.Single(d => d.DeclarationType == DeclarationType.Project && d.ProjectName == projectName); Assert.AreEqual(1, declaration.References.Count(), "Project reference expected"); @@ -160,7 +162,7 @@ public void NestedMemberAccessExpressions() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs b/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs index 1a41b1f7b6..426fa9c7dc 100644 --- a/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameDefaultBindingTests.cs @@ -66,6 +66,8 @@ public void EnclosingProjectComesBeforeOtherModuleInEnclosingProject() var vbe = builder.Build(); var state = Parse(vbe); var declaration = state.AllUserDeclarations.Single(d => d.DeclarationType == DeclarationType.Project && d.IdentifierName == BindingTargetName); + + Assert.AreEqual(state.Status, ParserState.Ready); Assert.AreEqual(1, declaration.References.Count()); } @@ -149,7 +151,7 @@ public void ReferencedProjectClassNotMarkedAsGlobalClassModuleIsNotReferenced() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs b/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs index 3cc1f13dcb..7173d0a504 100644 --- a/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameProcedurePointerBindingTests.cs @@ -49,6 +49,7 @@ public void EnclosingProjectComesBeforeOtherProceduralModule() var declaration = state.AllUserDeclarations.Single(d => d.DeclarationType == DeclarationType.Project && d.IdentifierName == BINDING_TARGET_NAME); + Assert.AreEqual(state.Status, ParserState.Ready); Assert.AreEqual(1, declaration.References.Count()); } @@ -71,7 +72,7 @@ public void OtherProceduralModule() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs b/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs index 917d8fe9fd..1ce04bbc98 100644 --- a/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs +++ b/RubberduckTests/Binding/SimpleNameTypeBindingTests.cs @@ -50,6 +50,7 @@ public void EnclosingProjectComesBeforeOtherModuleInEnclosingProject() var declaration = state.AllUserDeclarations.Single(d => d.DeclarationType == DeclarationType.Project && d.IdentifierName == BINDING_TARGET_NAME); + Assert.AreEqual(state.Status, ParserState.Ready); Assert.AreEqual(1, declaration.References.Count()); } @@ -134,7 +135,7 @@ public void ReferencedProjectType() private static RubberduckParserState Parse(Mock vbe) { - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status != ParserState.Ready) { diff --git a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs index 0b49e99cb5..1feee9ec0e 100644 --- a/RubberduckTests/CodeExplorer/CodeExplorerTests.cs +++ b/RubberduckTests/CodeExplorer/CodeExplorerTests.cs @@ -40,8 +40,8 @@ public void AddStdModule() var commands = new List { new AddStdModuleCommand(vbe.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -69,8 +69,8 @@ public void AddClassModule() var commands = new List { new AddClassModuleCommand(vbe.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -98,8 +98,8 @@ public void AddUserForm() var commands = new List { new AddUserFormCommand(vbe.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -128,7 +128,7 @@ public void AddTestModule() var configLoader = new Mock(null, null, null, null, null, null, null); configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDefaultUnitTestConfig()); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var vbeWrapper = vbe.Object; var commands = new List { @@ -136,7 +136,7 @@ public void AddTestModule() new Rubberduck.UI.Command.AddTestModuleCommand(vbeWrapper, state, configLoader.Object)) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -173,13 +173,13 @@ public void ImportModule() openFileDialog.Setup(o => o.FileNames).Returns(new[] {"C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"}); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -216,13 +216,13 @@ public void ImportMultipleModules() openFileDialog.Setup(o => o.FileNames).Returns(new[] { "C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas", "C:\\Users\\Rubberduck\\Desktop\\ClsModule1.cls" }); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -260,13 +260,13 @@ public void ImportModule_Cancel() openFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); openFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.Cancel); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new ImportCommand(vbe.Object, openFileDialog.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -295,13 +295,13 @@ public void ExportModule() saveFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); saveFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.OK); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new ExportCommand(saveFileDialog.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -330,13 +330,13 @@ public void ExportModule_Cancel() saveFileDialog.Setup(o => o.FileName).Returns("C:\\Users\\Rubberduck\\Desktop\\StdModule1.bas"); saveFileDialog.Setup(o => o.ShowDialog()).Returns(DialogResult.Cancel); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new ExportCommand(saveFileDialog.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -360,13 +360,13 @@ public void OpenDesigner() var vbe = builder.AddProject(project).Build(); var component = projectMock.MockComponents.First(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new OpenDesignerCommand() }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -412,8 +412,8 @@ public void RemoveCommand_RemovesModuleWhenPromptOk() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -456,8 +456,8 @@ public void RemoveCommand_CancelsWhenFilePromptCancels() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -500,8 +500,8 @@ public void RemoveCommand_GivenMsgBoxNO_RemovesModuleNoExport() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -543,8 +543,8 @@ public void RemoveModule_Cancel() new RemoveCommand(saveFileDialog.Object, messageBox.Object) }; - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -581,13 +581,13 @@ End Sub var project = vbe.Object.VBProjects[0]; var module = project.VBComponents[0].CodeModule; - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object,() => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -617,13 +617,13 @@ Dim d As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -664,13 +664,13 @@ End Sub var component2 = project.Object.VBComponents[1]; var module2 = component2.CodeModule; - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -721,13 +721,13 @@ End Sub var component2 = project.Object.VBComponents[1]; var module2 = component2.CodeModule; - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -760,13 +760,13 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -812,13 +812,13 @@ End Sub var component2 = project.Object.VBComponents[1]; var module2 = component2.CodeModule; - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -874,13 +874,13 @@ End Sub var component2 = project.Object.VBComponents[1]; var module2 = component2.CodeModule; - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -914,13 +914,13 @@ Dim d As Boolean var project = projectMock.Build(); var vbe = builder.AddProject(project).Build(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new IndentCommand(state, new Indenter(vbe.Object, () => Settings.IndenterSettingsTests.GetMockIndenterSettings()), null) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -967,13 +967,13 @@ Sub Bar() msgbox.Setup(m => m.Show(It.IsAny(), It.IsAny(), MessageBoxButtons.YesNo, It.IsAny())) .Returns(DialogResult.Yes); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List { new RenameCommand(vbe.Object, state, view.Object, msgbox.Object) }; - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -999,8 +999,8 @@ public void ExpandAllNodes() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, new List()); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1028,8 +1028,8 @@ public void ExpandAllNodes_StartingWithSubnode() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, new List()); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1058,8 +1058,8 @@ public void CollapseAllNodes() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, new List()); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1087,8 +1087,8 @@ public void CollapseAllNodes_StartingWithSubnode() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, new List()); + var state = new RubberduckParserState(vbe.Object); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, new List()); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1155,10 +1155,10 @@ public void CompareByType_ReturnsEventAboveConst() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1183,10 +1183,10 @@ public void CompareByType_ReturnsConstAboveField() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1214,10 +1214,10 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1246,10 +1246,10 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1278,10 +1278,10 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1310,10 +1310,10 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1342,10 +1342,10 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1371,10 +1371,10 @@ public void CompareByType_ReturnsClassModuleBelowDocument() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1407,10 +1407,10 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1439,10 +1439,10 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1471,10 +1471,10 @@ Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var commands = new List(); - var vm = new CodeExplorerViewModel(new FolderHelper(state, GetDelimiterConfigLoader()), state, commands); + var vm = new CodeExplorerViewModel(new FolderHelper(state), state, commands); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); @@ -1511,24 +1511,24 @@ private Configuration GetDefaultUnitTestConfig() return new Configuration(userSettings); } - private Configuration GetDelimiterConfig() - { - var settings = new GeneralSettings - { - Delimiter = '.' - }; + //private Configuration GetDelimiterConfig() + //{ + // var settings = new GeneralSettings + // { + // Delimiter = '.' + // }; - var userSettings = new UserSettings(settings, null, null, null, null, null, null); - return new Configuration(userSettings); - } + // var userSettings = new UserSettings(settings, null, null, null, null, null, null); + // return new Configuration(userSettings); + //} - private ConfigurationLoader GetDelimiterConfigLoader() - { - var configLoader = new Mock(null, null, null, null, null, null, null); - configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDelimiterConfig()); + //private ConfigurationLoader GetDelimiterConfigLoader() + //{ + // var configLoader = new Mock(null, null, null, null, null, null, null); + // configLoader.Setup(c => c.LoadConfiguration()).Returns(GetDelimiterConfig()); - return configLoader.Object; - } + // return configLoader.Object; + //} #endregion } } diff --git a/RubberduckTests/Commands/FindAllImplementationsTests.cs b/RubberduckTests/Commands/FindAllImplementationsTests.cs index 9197b0ea6f..3ff5011de8 100644 --- a/RubberduckTests/Commands/FindAllImplementationsTests.cs +++ b/RubberduckTests/Commands/FindAllImplementationsTests.cs @@ -44,7 +44,7 @@ Public Sub IClass1_Foo() var vbe = builder.AddProject(project).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -82,7 +82,7 @@ Public Sub IClass1_Foo() var vbe = builder.AddProject(project).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -126,7 +126,7 @@ Public Sub Buzz() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -153,7 +153,7 @@ public void FindAllImplementations_NoResults_DisplayMessageBox() var vbe = builder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, default(Selection)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -196,7 +196,7 @@ Public Sub IClass1_Foo() var vbe = builder.AddProject(project).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -222,7 +222,7 @@ public void FindAllImplementations_NullTarget_Aborts() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -256,7 +256,7 @@ Private Sub Bar() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -282,7 +282,7 @@ public void FindAllImplementations_CanExecute_NullTarget() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -314,7 +314,7 @@ Private Sub Bar() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -338,7 +338,7 @@ public void FindAllImplementations_CanExecute_NullActiveCodePane() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Commands/FindAllReferencesTests.cs b/RubberduckTests/Commands/FindAllReferencesTests.cs index c65d230b5c..658001924a 100644 --- a/RubberduckTests/Commands/FindAllReferencesTests.cs +++ b/RubberduckTests/Commands/FindAllReferencesTests.cs @@ -38,7 +38,7 @@ Private Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -71,7 +71,7 @@ Private Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, new Selection(5, 5, 5, 5)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -98,7 +98,7 @@ public void FindAllReferences_NoResults_DisplayMessageBox() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -135,7 +135,7 @@ Private Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -161,7 +161,7 @@ public void FindAllReferences_NullTarget_Aborts() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -195,7 +195,7 @@ Private Sub Bar() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -221,7 +221,7 @@ public void FindAllReferences_CanExecute_NullTarget() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -253,7 +253,7 @@ Private Sub Bar() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -277,7 +277,7 @@ public void FindAllReferences_CanExecute_NullActiveCodePane() vbe.Setup(s => s.ActiveCodePane).Returns(value: null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Commands/IndentCommandTests.cs b/RubberduckTests/Commands/IndentCommandTests.cs index b95832aee7..d34fc6cd42 100644 --- a/RubberduckTests/Commands/IndentCommandTests.cs +++ b/RubberduckTests/Commands/IndentCommandTests.cs @@ -24,7 +24,7 @@ public void AddNoIndentAnnotation() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); var module = component.CodeModule; parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -62,7 +62,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(input, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -87,7 +87,7 @@ public void AddNoIndentAnnotation_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane) null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -109,7 +109,7 @@ public void AddNoIndentAnnotation_CanExecute_ModuleAlreadyHasAnnotation() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -166,7 +166,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -195,7 +195,7 @@ public void IndentModule_CanExecute_NullActiveCodePane() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -216,7 +216,7 @@ public void IndentModule_CanExecute() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) diff --git a/RubberduckTests/Commands/RefactorCommandTests.cs b/RubberduckTests/Commands/RefactorCommandTests.cs index d9808d108b..97c412b3af 100644 --- a/RubberduckTests/Commands/RefactorCommandTests.cs +++ b/RubberduckTests/Commands/RefactorCommandTests.cs @@ -26,7 +26,7 @@ public void EncapsulateField_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -47,7 +47,7 @@ public void EncapsulateField_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -74,7 +74,7 @@ Dim d As Boolean var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 9, 2, 9)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -100,7 +100,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 7, 2, 7)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -126,7 +126,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -148,7 +148,7 @@ public void ExtractInterface_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -169,7 +169,7 @@ public void ExtractInterface_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleModule("", ComponentType.ClassModule, out component, new Selection()); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -191,7 +191,7 @@ public void ExtractInterface_CanExecute_NoMembers() var vbe = builder.BuildFromSingleModule("Option Explicit", ComponentType.ClassModule, out component, new Selection()); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -216,7 +216,7 @@ public void ExtractInterface_CanExecute_Proc_StdModule() var vbe = builder.BuildFromSingleStandardModule(input, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -237,7 +237,7 @@ public void ExtractInterface_CanExecute_Field() var vbe = builder.BuildFromSingleModule("Dim d As Boolean", ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -278,7 +278,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -310,7 +310,7 @@ public void ExtractInterface_CanExecute_ClassWithMembers_SameNameAsClassWithMemb var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -335,7 +335,7 @@ public void ExtractInterface_CanExecute_Proc() var vbe = builder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -361,7 +361,7 @@ public void ExtractInterface_CanExecute_Function() var vbe = builder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -386,7 +386,7 @@ public void ExtractInterface_CanExecute_PropertyGet() var vbe = builder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -411,7 +411,7 @@ public void ExtractInterface_CanExecute_PropertyLet() var vbe = builder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -436,7 +436,7 @@ public void ExtractInterface_CanExecute_PropertySet() var vbe = builder.BuildFromSingleModule(input, ComponentType.ClassModule, out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -458,7 +458,7 @@ public void ImplementInterface_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -479,7 +479,7 @@ public void ImplementInterface_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -501,7 +501,7 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceNotSelected() var vbe = builder.BuildFromSingleModule("", ComponentType.ClassModule, out component, new Selection()); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -526,7 +526,7 @@ public void ImplementInterface_CanExecute_ImplementsInterfaceSelected() var vbe = builder.AddProject(project).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -548,7 +548,7 @@ public void IntroduceField_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -570,7 +570,7 @@ public void IntroduceField_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -593,7 +593,7 @@ public void IntroduceField_CanExecute_Field() var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -620,7 +620,7 @@ Dim d As Boolean var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -643,7 +643,7 @@ public void IntroduceParameter_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -665,7 +665,7 @@ public void IntroduceParameter_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -688,7 +688,7 @@ public void IntroduceParameter_CanExecute_Field() var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -715,7 +715,7 @@ Dim d As Boolean var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -738,7 +738,7 @@ public void MoveCloserToUsage_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -759,7 +759,7 @@ public void MoveCloserToUsage_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -781,7 +781,7 @@ public void MoveCloserToUsage_CanExecute_Field_NoReferences() var vbe = builder.BuildFromSingleStandardModule("Dim d As Boolean", out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -807,7 +807,7 @@ Dim d As Boolean var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -828,7 +828,7 @@ public void MoveCloserToUsage_CanExecute_Const_NoReferences() var vbe = builder.BuildFromSingleStandardModule("Private Const const_abc = 0", out component, Selection.Home); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -855,7 +855,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 5, 1, 5)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -882,7 +882,7 @@ Dim d As Boolean var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(2, 10, 2, 10)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -910,7 +910,7 @@ Dim d As Integer var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 17, 1, 17)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -932,7 +932,7 @@ public void RemoveParameters_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -953,7 +953,7 @@ public void RemoveParameters_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -978,7 +978,7 @@ public void RemoveParameters_CanExecute_Event_NoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1003,7 +1003,7 @@ public void RemoveParameters_CanExecute_Proc_NoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1028,7 +1028,7 @@ public void RemoveParameters_CanExecute_Function_NoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1053,7 +1053,7 @@ public void RemoveParameters_CanExecute_PropertyGet_NoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1078,7 +1078,7 @@ public void RemoveParameters_CanExecute_PropertyLet_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1103,7 +1103,7 @@ public void RemoveParameters_CanExecute_PropertySet_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1127,7 +1127,7 @@ public void RemoveParameters_CanExecute_Event_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1152,7 +1152,7 @@ public void RemoveParameters_CanExecute_Proc_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1177,7 +1177,7 @@ public void RemoveParameters_CanExecute_Function_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1202,7 +1202,7 @@ public void RemoveParameters_CanExecute_PropertyGet_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1227,7 +1227,7 @@ public void RemoveParameters_CanExecute_PropertyLet_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1252,7 +1252,7 @@ public void RemoveParameters_CanExecute_PropertySet_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1274,7 +1274,7 @@ public void ReorderParameters_CanExecute_NullActiveCodePane() vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1295,7 +1295,7 @@ public void ReorderParameters_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1320,7 +1320,7 @@ public void ReorderParameters_CanExecute_Event_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1345,7 +1345,7 @@ public void ReorderParameters_CanExecute_Proc_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1370,7 +1370,7 @@ public void ReorderParameters_CanExecute_Function_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1395,7 +1395,7 @@ public void ReorderParameters_CanExecute_PropertyGet_OneParam() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1420,7 +1420,7 @@ public void ReorderParameters_CanExecute_PropertyLet_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1445,7 +1445,7 @@ public void ReorderParameters_CanExecute_PropertySet_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1469,7 +1469,7 @@ public void ReorderParameters_CanExecute_Event_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1494,7 +1494,7 @@ public void ReorderParameters_CanExecute_Proc_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 6, 1, 6)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1519,7 +1519,7 @@ public void ReorderParameters_CanExecute_Function_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 11, 1, 11)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1544,7 +1544,7 @@ public void ReorderParameters_CanExecute_PropertyGet_TwoParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1569,7 +1569,7 @@ public void ReorderParameters_CanExecute_PropertyLet_ThreeParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -1594,7 +1594,7 @@ public void ReorderParameters_CanExecute_PropertySet_ThreeParams() var vbe = builder.BuildFromSingleStandardModule(input, out component, new Selection(1, 16, 1, 16)); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) diff --git a/RubberduckTests/Commands/UnitTestCommandTests.cs b/RubberduckTests/Commands/UnitTestCommandTests.cs index 35f0eb483d..ddc5e45702 100644 --- a/RubberduckTests/Commands/UnitTestCommandTests.cs +++ b/RubberduckTests/Commands/UnitTestCommandTests.cs @@ -32,7 +32,7 @@ Private Assert As Object var vbe = builder.BuildFromSingleStandardModule(string.Format(input, string.Empty), out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -69,7 +69,7 @@ Private Assert As Object vbe.Setup(s => s.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -94,7 +94,7 @@ public void AddTest_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -116,7 +116,7 @@ public void AddTest_CanExecute_NoTestModule() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -145,7 +145,7 @@ Private Assert As Object var vbe = builder.BuildFromSingleStandardModule(input, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -175,7 +175,7 @@ Private Assert As Object var vbe = builder.BuildFromSingleStandardModule(string.Format(input, string.Empty), out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -200,7 +200,7 @@ public void AddExpectedErrorTest_CanExecute_NonReadyState() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -222,7 +222,7 @@ public void AddExpectedErrorTest_CanExecute_NoTestModule() var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -251,7 +251,7 @@ Private Assert As Object var vbe = builder.BuildFromSingleStandardModule(input, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) @@ -281,7 +281,7 @@ Private Assert As Object vbe.Setup(s => s.ActiveCodePane).Returns((ICodePane)null); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -311,7 +311,7 @@ Private Assert As New Rubberduck.AssertClass var vbe = builder.BuildFromSingleStandardModule("", out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) diff --git a/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs b/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs index c346e3cbe9..075d22e835 100644 --- a/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs +++ b/RubberduckTests/Grammar/ParserRuleContextExtensionTests.cs @@ -44,7 +44,7 @@ End _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Grammar/ResolverTests.cs b/RubberduckTests/Grammar/ResolverTests.cs index 8d4319b70f..0599770ca4 100644 --- a/RubberduckTests/Grammar/ResolverTests.cs +++ b/RubberduckTests/Grammar/ResolverTests.cs @@ -23,7 +23,7 @@ private RubberduckParserState Resolve(string code, bool loadStdLib = false, Comp IVBComponent component; var vbe = builder .BuildFromSingleModule(code, moduleType, out component, Selection.Empty, loadStdLib); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -51,7 +51,7 @@ private RubberduckParserState Resolve(params string[] classes) builder.AddProject(project); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -79,7 +79,7 @@ private RubberduckParserState Resolve(params Tuple[] comp builder.AddProject(project); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -2163,7 +2163,7 @@ End Sub builder.AddProject(project.Build()); var vbe = builder.Build(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.ResolverError) @@ -2213,6 +2213,7 @@ End Property var usages = declaration.References.Where(item => item.ParentNonScoping.IdentifierName == "DoSomething"); + Assert.AreEqual(state.Status, ParserState.Ready); Assert.AreEqual(1, usages.Count()); } diff --git a/RubberduckTests/Grammar/VBAParserValidityTests.cs b/RubberduckTests/Grammar/VBAParserValidityTests.cs index f70a1fc599..7418bc1b8e 100644 --- a/RubberduckTests/Grammar/VBAParserValidityTests.cs +++ b/RubberduckTests/Grammar/VBAParserValidityTests.cs @@ -47,7 +47,7 @@ private static string Parse(string code, string filename) var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error: " + filename); } diff --git a/RubberduckTests/Inspections/ApplicationWorksheetFunctionInspectionTests.cs b/RubberduckTests/Inspections/ApplicationWorksheetFunctionInspectionTests.cs index 73c84bdb9e..5ad6304eff 100644 --- a/RubberduckTests/Inspections/ApplicationWorksheetFunctionInspectionTests.cs +++ b/RubberduckTests/Inspections/ApplicationWorksheetFunctionInspectionTests.cs @@ -27,7 +27,7 @@ private static ParseCoordinator ArrangeParser(string inputCode) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); return parser; @@ -207,7 +207,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -274,7 +274,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); @@ -321,7 +321,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); @@ -372,7 +372,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); @@ -419,7 +419,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); diff --git a/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs b/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs index 8faaaff69b..4554509dff 100644 --- a/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/AssignedByValParameterInspectionTests.cs @@ -6,7 +6,6 @@ using Rubberduck.Inspections.QuickFixes; using Rubberduck.Inspections.Resources; using Rubberduck.Parsing.VBA; -using Rubberduck.VBEditor.Application; using Rubberduck.VBEditor.Events; using Rubberduck.VBEditor.SafeComWrappers.Abstract; using RubberduckTests.Mocks; @@ -25,21 +24,7 @@ public void AssignedByValParameter_ReturnsResult_Sub() Let arg1 = ""test"" End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.AreEqual(1, inspectionResults.Count()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 1); } [TestMethod] @@ -51,21 +36,7 @@ public void AssignedByValParameter_ReturnsResult_Function() Let arg1 = 9 End Function"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.AreEqual(1, inspectionResults.Count()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 1); } [TestMethod] @@ -78,21 +49,7 @@ public void AssignedByValParameter_ReturnsResult_MultipleParams() Let arg2 = 9 End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.AreEqual(2, inspectionResults.Count()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 2); } [TestMethod] @@ -103,21 +60,7 @@ public void AssignedByValParameter_DoesNotReturnResult() @"Public Sub Foo(ByVal arg1 As String) End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.AreEqual(0, inspectionResults.Count()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 0); } [TestMethod] @@ -130,21 +73,7 @@ Public Sub Foo(ByVal arg1 As String) Let arg1 = ""test"" End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.IsFalse(inspectionResults.Any()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 0); } [TestMethod] @@ -159,21 +88,7 @@ Dim var1 As Integer var1 = arg2 End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); - - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } - - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); - - Assert.AreEqual(1, inspectionResults.Count()); + AssertVbaFragmentYieldsExpectedInspectionResultCount(inputCode, 1); } [TestMethod] @@ -184,69 +99,152 @@ public void AssignedByValParameter_QuickFixWorks() @"Public Sub Foo(ByVal arg1 As String) Let arg1 = ""test"" End Sub"; - const string expectedCode = @"Public Sub Foo(ByRef arg1 As String) Let arg1 = ""test"" End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var project = vbe.Object.VBProjects[0]; - var module = project.VBComponents[0].CodeModule; - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var quickFixResult = ApplyPassParameterByReferenceQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); + } - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + [TestMethod] + [TestCategory("Inspections")] + public void AssignedByValParameter_IgnoreQuickFixWorks() + { + const string inputCode = +@"Public Sub Foo(ByVal arg1 As String) + Let arg1 = ""test"" +End Sub"; - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); + const string expectedCode = +@"'@Ignore AssignedByValParameter +Public Sub Foo(ByVal arg1 As String) + Let arg1 = ""test"" +End Sub"; - inspectionResults.First().QuickFixes.First().Fix(); + var quickFixResult = ApplyIgnoreOnceQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); + } - Assert.AreEqual(expectedCode, module.Content()); + [TestMethod] + [TestCategory("Inspections")] + public void AssignedByValParameter_LocalVariableAssignment() + { + const string inputCode = +@"Public Sub Foo(ByVal arg1 As String) + Let arg1 = ""test"" +End Sub"; + + const string expectedCode = +@"Public Sub Foo(ByVal arg1 As String) +Dim localArg1 As String +localArg1 = arg1 + Let localArg1 = ""test"" +End Sub"; + + var quickFixResult = ApplyLocalVariableQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); } [TestMethod] [TestCategory("Inspections")] - public void AssignedByValParameter_IgnoreQuickFixWorks() + public void AssignedByValParameter_LocalVariableAssignment_NameInUse() { + //Punt if the user-defined or auto-generated name is already used in the method const string inputCode = @"Public Sub Foo(ByVal arg1 As String) + Dim localArg1 as string Let arg1 = ""test"" End Sub"; const string expectedCode = -@"'@Ignore AssignedByValParameter -Public Sub Foo(ByVal arg1 As String) +@"Public Sub Foo(ByVal arg1 As String) + Dim localArg1 as string Let arg1 = ""test"" End Sub"; - //Arrange - var builder = new MockVbeBuilder(); - IVBComponent component; - var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); - var project = vbe.Object.VBProjects[0]; - var module = project.VBComponents[0].CodeModule; - var mockHost = new Mock(); - mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var quickFixResult = ApplyLocalVariableQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); + } - parser.Parse(new CancellationTokenSource()); - if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + [TestMethod] + [TestCategory("Inspections")] + public void AssignedByValParameter_LocalVariableAssignment_NameInUseOtherSub() + { + //Make sure the modified code stays within the specific method under repair + const string inputCode = +@" +Public Function Bar2(ByVal arg2 As String) As String + Dim arg1 As String + Let arg1 = ""Test1"" + Bar2 = arg1 +End Function - var inspection = new AssignedByValParameterInspection(parser.State); - var inspectionResults = inspection.GetInspectionResults(); +Public Sub Foo(ByVal arg1 As String) + Let arg1 = ""test"" +End Sub - inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix(); +Public Sub Bar(ByVal arg2 As String) + Dim arg1 As String + Let arg1 = ""Test2"" +End Sub" +; + + const string expectedCode = +@" +Public Function Bar2(ByVal arg2 As String) As String + Dim arg1 As String + Let arg1 = ""Test1"" + Bar2 = arg1 +End Function + +Public Sub Foo(ByVal arg1 As String) +Dim localArg1 As String +localArg1 = arg1 + Let localArg1 = ""test"" +End Sub + +Public Sub Bar(ByVal arg2 As String) + Dim arg1 As String + Let arg1 = ""Test2"" +End Sub" +; + + var quickFixResult = ApplyLocalVariableQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); + } + + [TestMethod] + [TestCategory("Inspections")] + public void AssignedByValParameter_LocalVariableAssignment_FunctionReturn() + { + const string inputCode = +@"Private Function MessingWithByValParameters(leaveAlone As Integer, ByVal messWithThis As String) As String + If leaveAlone > 10 Then + messWithThis = messWithThis & CStr(leaveAlone) + messWithThis = Replace(messWithThis, ""OK"", ""yes"") + End If + MessingWithByValParameters = messWithThis +End Function +"; - Assert.AreEqual(expectedCode, module.Content()); + const string expectedCode = +@"Private Function MessingWithByValParameters(leaveAlone As Integer, ByVal messWithThis As String) As String +Dim localMessWithThis As String +localMessWithThis = messWithThis + If leaveAlone > 10 Then + localMessWithThis = localMessWithThis & CStr(leaveAlone) + localMessWithThis = Replace(localMessWithThis, ""OK"", ""yes"") + End If + MessingWithByValParameters = localMessWithThis +End Function +"; + var quickFixResult = ApplyLocalVariableQuickFixToVBAFragment(inputCode); + Assert.AreEqual(expectedCode, quickFixResult); } + [TestMethod] [TestCategory("Inspections")] public void InspectionType() @@ -264,5 +262,75 @@ public void InspectionName() Assert.AreEqual(inspectionName, inspection.Name); } + + private string ApplyPassParameterByReferenceQuickFixToVBAFragment(string inputCode) + { + var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode); + var inspectionResults = GetInspectionResults(vbe); + + inspectionResults.First().QuickFixes.Single(s => s is PassParameterByReferenceQuickFix).Fix(); + + return GetModifiedContent(vbe); + } + + private string ApplyLocalVariableQuickFixToVBAFragment(string inputCode) + { + var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode); + var inspectionResults = GetInspectionResults(vbe); + + var quickFixBase = inspectionResults.First().QuickFixes.Single(s => s is AssignedByValParameterQuickFix); + AssignedByValParameterQuickFix assignByValParamQFix = (AssignedByValParameterQuickFix)quickFixBase; + assignByValParamQFix.TESTONLY_FixUsingAutoGeneratedName(); + return GetModifiedContent(vbe); + } + private string ApplyIgnoreOnceQuickFixToVBAFragment(string inputCode) + { + var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode); + var inspectionResults = GetInspectionResults(vbe); + + inspectionResults.First().QuickFixes.Single(s => s is IgnoreOnceQuickFix).Fix(); + + return GetModifiedContent(vbe); + } + private string GetModifiedContent(Mock vbe) + { + var project = vbe.Object.VBProjects[0]; + var module = project.VBComponents[0].CodeModule; + return module.Content(); + } + private System.Collections.Generic.IEnumerable GetInspectionResults(string inputCode) + { + var vbe = BuildMockVBEStandardModuleForVBAFragment(inputCode); + return GetInspectionResults(vbe); + } + private System.Collections.Generic.IEnumerable GetInspectionResults(Mock vbe) + { + var parser = GetMockParseCoordinator(vbe); + var inspection = new AssignedByValParameterInspection(parser.State); + return inspection.GetInspectionResults(); + } + private void AssertVbaFragmentYieldsExpectedInspectionResultCount(string inputCode, int expectedCount) + { + var inspectionResults = GetInspectionResults(inputCode); + Assert.AreEqual(expectedCount, inspectionResults.Count()); + } + private Mock BuildMockVBEStandardModuleForVBAFragment(string inputCode) + { + var builder = new MockVbeBuilder(); + IVBComponent component; + return builder.BuildFromSingleStandardModule(inputCode, out component); + //TODO: removal of the two lines below have no effect on the outcome of any test...remove? + //var mockHost = new Mock(); + //mockHost.SetupAllProperties(); + + } + private ParseCoordinator GetMockParseCoordinator(Mock vbe) + { + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + return parser; + } } } diff --git a/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs index cf9581409e..5fffdc5743 100644 --- a/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ConstantNotUsedInspectionTests.cs @@ -31,7 +31,7 @@ public void ConstantNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -58,7 +58,7 @@ public void ConstantNotUsed_ReturnsResult_MultipleConsts() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -90,7 +90,7 @@ Public Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -120,7 +120,7 @@ Public Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -147,7 +147,7 @@ public void ConstantNotUsed_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -179,7 +179,7 @@ public void ConstantNotUsed_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -215,7 +215,7 @@ public void ConstantNotUsed_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs b/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs index d92ac31763..d83e37f0e1 100644 --- a/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs +++ b/RubberduckTests/Inspections/DefaultProjectNameInspectionTests.cs @@ -29,7 +29,7 @@ public void DefaultProjectName_ReturnsResult() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -53,7 +53,7 @@ public void DefaultProjectName_DoesNotReturnResult() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -77,7 +77,7 @@ public void DefaultProjectName_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs b/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs index d329868607..1ac147106b 100644 --- a/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs +++ b/RubberduckTests/Inspections/EmptyStringLiteralInspectionTests.cs @@ -41,7 +41,7 @@ Public Sub Foo(ByRef arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -73,7 +73,7 @@ public void EmptyStringLiteral_ReturnsResult_Assignment() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -105,7 +105,7 @@ public void NotEmptyStringLiteral_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -138,7 +138,7 @@ public void EmptyStringLiteral_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -177,7 +177,7 @@ public void EmptyStringLiteral_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -219,7 +219,7 @@ public void EmptyStringLiteral_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs b/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs index 70f13c4cce..f1fb629cf7 100644 --- a/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs +++ b/RubberduckTests/Inspections/EncapsulatePublicFieldInspectionTests.cs @@ -29,7 +29,7 @@ public void PublicField_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -55,7 +55,7 @@ public void MultiplePublicFields_ReturnMultipleResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ public void PrivateField_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -104,7 +104,7 @@ public void PublicNonField_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ public void PublicField_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -159,7 +159,7 @@ public void EncapsulatePublicField_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs index 6df8bffd31..c9e2275328 100644 --- a/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/FunctionReturnValueNotUsedInspectionTests.cs @@ -33,7 +33,7 @@ Call Foo(""Test"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -60,7 +60,7 @@ Public Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +87,7 @@ Bar AddressOf Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -113,7 +113,7 @@ Public Sub Bar() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -141,7 +141,7 @@ Bar AddressOf Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -169,7 +169,7 @@ Foo Foo(Foo(""Bar"")) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -198,7 +198,7 @@ End If var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -229,7 +229,7 @@ Next Bar var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -260,7 +260,7 @@ While Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -291,7 +291,7 @@ Do Until Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -319,7 +319,7 @@ Public Sub Baz() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -348,7 +348,7 @@ End If var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -378,7 +378,7 @@ Bar Foo(""Test"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -404,7 +404,7 @@ public void FunctionReturnValueNotUsed_DoesNotReturnResult_IgnoresBuiltInFunctio var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -446,7 +446,7 @@ Dim result As Integer var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -487,7 +487,7 @@ Dim testObj As IFoo var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -526,7 +526,7 @@ End If var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -572,7 +572,7 @@ Sub goo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -627,7 +627,7 @@ Dim testObj As IFoo var vbe = projectBuilder.MockVbeBuilder().Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -671,7 +671,7 @@ Public Sub Goo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/HostSpecificExpressionInspectionTests.cs b/RubberduckTests/Inspections/HostSpecificExpressionInspectionTests.cs index aaf0226533..dde8d594aa 100644 --- a/RubberduckTests/Inspections/HostSpecificExpressionInspectionTests.cs +++ b/RubberduckTests/Inspections/HostSpecificExpressionInspectionTests.cs @@ -36,7 +36,7 @@ End Sub mockHost.SetupGet(m => m.ApplicationName).Returns("Excel"); vbe.Setup(m => m.HostApplication()).Returns(() => mockHost.Object); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("VBA.4.2.xml"); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); diff --git a/RubberduckTests/Inspections/HungarianNotationInspectionTests.cs b/RubberduckTests/Inspections/HungarianNotationInspectionTests.cs index 84d120deb5..829db2a80c 100644 --- a/RubberduckTests/Inspections/HungarianNotationInspectionTests.cs +++ b/RubberduckTests/Inspections/HungarianNotationInspectionTests.cs @@ -32,7 +32,7 @@ Dim strFoo As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -61,7 +61,7 @@ Dim oFoo As Object var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -90,7 +90,7 @@ public void HungarianNotation_ReturnsResult_ForClass() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -119,7 +119,7 @@ Dim strong As Variant var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -146,7 +146,7 @@ public void HungarianNotation_DoesNotReturnsResult_UpperCaseFirstLetter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -174,7 +174,7 @@ Dim col As Long var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -203,7 +203,7 @@ Dim strFoo As Variant var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -231,7 +231,7 @@ Dim oRange As Object var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/IgnoreOnceQuickFixTests.cs b/RubberduckTests/Inspections/IgnoreOnceQuickFixTests.cs index 0c34b1dd8b..9ab352cfd0 100644 --- a/RubberduckTests/Inspections/IgnoreOnceQuickFixTests.cs +++ b/RubberduckTests/Inspections/IgnoreOnceQuickFixTests.cs @@ -49,7 +49,7 @@ End Function var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs b/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs index 0009c1ba11..0cb3f57638 100644 --- a/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitActiveSheetReferenceInspectionTests.cs @@ -40,7 +40,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); @@ -77,7 +77,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -117,7 +117,7 @@ Dim arr1() As Variant var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); diff --git a/RubberduckTests/Inspections/ImplicitActiveWorkbookReferenceInspectionTests.cs b/RubberduckTests/Inspections/ImplicitActiveWorkbookReferenceInspectionTests.cs index a8f68ed97e..c3295e4702 100644 --- a/RubberduckTests/Inspections/ImplicitActiveWorkbookReferenceInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitActiveWorkbookReferenceInspectionTests.cs @@ -39,7 +39,7 @@ Dim sheet As Worksheet var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); @@ -76,7 +76,7 @@ Dim sheet As Worksheet var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); @@ -119,7 +119,7 @@ Dim sheet As Worksheet var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Excel.1.8.xml"); parser.Parse(new CancellationTokenSource()); diff --git a/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs b/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs index 3d43398540..446a6dde00 100644 --- a/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitByRefParameterInspectionTests.cs @@ -31,7 +31,7 @@ public void ImplicitByRefParameter_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void ImplicitByRefParameter_ReturnsResult_MultipleParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -81,7 +81,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ByRef() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -106,7 +106,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ByVal() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -131,7 +131,7 @@ public void ImplicitByRefParameter_DoesNotReturnResult_ParamArray() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -156,7 +156,7 @@ public void ImplicitByRefParameter_ReturnsResult_SomePassedByRefImplicitely() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -191,7 +191,7 @@ Sub IClass1_Foo(arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -217,7 +217,7 @@ Sub Foo(arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -248,7 +248,7 @@ public void ImplicitByRefParameter_QuickFixWorks_PassByRef() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -282,7 +282,7 @@ Sub Foo(arg1 As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -316,7 +316,7 @@ public void ImplicitByRefParameter_QuickFixWorks_OptionalParameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -356,7 +356,7 @@ bar _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -394,7 +394,7 @@ public void ImplicitByRefParameter_QuickFixWorks_LineContinuation() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -434,7 +434,7 @@ ByRef bar _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs b/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs index 61e51828e0..386aaffac9 100644 --- a/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs @@ -31,7 +31,7 @@ End Sub var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ public void ImplicitPublicMember_ReturnsResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -85,7 +85,7 @@ Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -110,7 +110,7 @@ public void ImplicitPublicMember_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -137,7 +137,7 @@ End Sub var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -165,7 +165,7 @@ Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -200,7 +200,7 @@ public void ImplicitPublicMember_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -238,7 +238,7 @@ Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs b/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs index cb571f10a6..21d181a517 100644 --- a/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs +++ b/RubberduckTests/Inspections/ImplicitVariantReturnTypeInspectionTests.cs @@ -30,7 +30,7 @@ public void ImplicitVariantReturnType_ReturnsResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -64,7 +64,7 @@ public void ImplicitVariantReturnType_ReturnsResult_LibraryFunction() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -98,7 +98,7 @@ public void ImplicitVariantReturnType_DoesNotReturnResult_LibraryFunction() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -123,7 +123,7 @@ public void ImplicitVariantReturnType_ReturnsResult_PropertyGet() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -151,7 +151,7 @@ Function Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -176,7 +176,7 @@ public void ImplicitVariantReturnType_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -204,7 +204,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -230,7 +230,7 @@ Function Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -261,7 +261,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -294,7 +294,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_PropertyGet() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -345,7 +345,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_LibraryFunction() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -378,7 +378,7 @@ public void ImplicitVariantReturnType_QuickFixWorks_Function_HasComment() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -412,7 +412,7 @@ Function Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs b/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs index f186ba5d05..f687fbff5c 100644 --- a/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs +++ b/RubberduckTests/Inspections/MalformedAnnotationInspectionTests.cs @@ -37,7 +37,7 @@ public void MalformedAnnotation_ReturnsResult_Folder() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -67,7 +67,7 @@ public void MalformedAnnotation_DoesNotReturnResult_Folder() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -97,7 +97,7 @@ public void MalformedAnnotation_ReturnsResult_Ignore() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -127,7 +127,7 @@ public void MalformedAnnotation_DoesNotReturnResult_Ignore() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -158,7 +158,7 @@ public void MalformedAnnotation_ReturnsMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -192,7 +192,7 @@ public void MalformedAnnotation_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MemberNotOnInterfaceInspectionTests.cs b/RubberduckTests/Inspections/MemberNotOnInterfaceInspectionTests.cs index 00ebd0ca07..59a32647d1 100644 --- a/RubberduckTests/Inspections/MemberNotOnInterfaceInspectionTests.cs +++ b/RubberduckTests/Inspections/MemberNotOnInterfaceInspectionTests.cs @@ -31,7 +31,7 @@ private static ParseCoordinator ArrangeParser(string inputCode, string library = var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary(library.Equals("Scripting") ? "Scripting.1.0.xml" : "Excel.1.8.xml"); return parser; diff --git a/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs b/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs index 11086fad58..0b06632ed1 100644 --- a/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/MoveFieldCloserToUsageInspectionTests.cs @@ -32,7 +32,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -62,7 +62,7 @@ Public Sub For2() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -89,7 +89,7 @@ Dim bar As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -115,7 +115,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -142,7 +142,7 @@ Public Property Get Foo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -172,7 +172,7 @@ Public Property Let Foo(ByVal value As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -202,7 +202,7 @@ Public Property Set Foo(ByVal value As Variant) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -230,7 +230,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -265,7 +265,7 @@ Public Sub Foo() var module = vbe.Object.VBProjects[0].VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -303,7 +303,7 @@ Dim bar As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs b/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs index 351d67d368..7475a824c5 100644 --- a/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs +++ b/RubberduckTests/Inspections/MultilineParameterInspectionTests.cs @@ -33,7 +33,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -58,7 +58,7 @@ public void MultilineParameter_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -91,7 +91,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -119,7 +119,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -148,7 +148,7 @@ As _ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -184,7 +184,7 @@ As _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -226,7 +226,7 @@ As _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs b/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs index e0dcc51287..5e1a7a5504 100644 --- a/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs +++ b/RubberduckTests/Inspections/MultipleDeclarationsInspectionTests.cs @@ -31,7 +31,7 @@ public void MultipleDeclarations_ReturnsResult_Variables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -57,7 +57,7 @@ public void MultipleDeclarations_ReturnsResult_Constants() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -83,7 +83,7 @@ public void MultipleDeclarations_ReturnsResult_StaticVariables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -110,7 +110,7 @@ public void MultipleDeclarations_ReturnsResult_MultipleDeclarations() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -137,7 +137,7 @@ Dim var3 As Boolean var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -164,7 +164,7 @@ public void MultipleDeclarations_Ignore_DoesNotReturnResult_Variables() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -199,7 +199,7 @@ Dim var2 As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ public void MultipleDeclarations_QuickFixWorks_Constants() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -273,7 +273,7 @@ Static var2 As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -309,7 +309,7 @@ public void MultipleDeclarations_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs b/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs index 4bb4ffe188..5e5b0e79bd 100644 --- a/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs +++ b/RubberduckTests/Inspections/MultipleFolderAnnotationsInspectionTests.cs @@ -32,7 +32,7 @@ public void NoFolderAnnotation_NoResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -59,7 +59,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +87,7 @@ Public Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -118,7 +118,7 @@ Public Sub Foo() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs b/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs index e51932d8fc..45bcef7cd2 100644 --- a/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs +++ b/RubberduckTests/Inspections/NonReturningFunctionInspectionTests.cs @@ -31,7 +31,7 @@ public void NonReturningFunction_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void NonReturningPropertyGet_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -84,7 +84,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -110,7 +110,7 @@ public void NonReturningFunction_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -136,7 +136,7 @@ Function Foo() As Boolean var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -165,7 +165,7 @@ Function Goo() As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -200,7 +200,7 @@ Function IClass1_Foo() As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -231,7 +231,7 @@ public void NonReturningFunction_QuickFixWorks_Function() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -264,7 +264,7 @@ public void GivenFunctionNameWithTypeHint_SubNameHasNoTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -297,7 +297,7 @@ public void NonReturningFunction_QuickFixWorks_FunctionReturnsImplicitVariant() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -330,7 +330,7 @@ public void NonReturningFunction_QuickFixWorks_FunctionHasVariable() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -363,7 +363,7 @@ public void GivenNonReturningPropertyGetter_QuickFixConvertsToSub() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -396,7 +396,7 @@ public void GivenNonReturningPropertyGetWithTypeHint_QuickFixDropsTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -429,7 +429,7 @@ public void GivenImplicitVariantPropertyGetter_StillConvertsToSub() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -462,7 +462,7 @@ public void GivenParameterizedPropertyGetter_QuickFixKeepsParameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -499,7 +499,7 @@ Function IClass1_Foo() As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -532,7 +532,7 @@ Function Foo() As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs b/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs index 4a440ed9fe..bd965aedd4 100644 --- a/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs +++ b/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs @@ -36,7 +36,7 @@ Dim target As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -67,7 +67,7 @@ Dim target As Variant var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -98,7 +98,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -130,7 +130,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -161,7 +161,7 @@ Dim target As Range var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -197,7 +197,7 @@ Set temp(1) = New Dictionary var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.State.AddTestLibrary("Scripting.1.0.xml"); @@ -242,7 +242,7 @@ Dim target As Range var module = vbe.Object.VBProjects[0].VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -284,7 +284,7 @@ End If var module = vbe.Object.VBProjects[0].VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -323,7 +323,7 @@ End Property var module = vbe.Object.VBProjects[0].VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -338,5 +338,32 @@ End Property } Assert.AreEqual(expectedCode, module.Content()); } + + [TestMethod] + [TestCategory("Inspections")] + public void ObjectVariableNotSet_LongPtrVariable_ReturnsNoResult() + { + const string inputCode = @" +Private Sub TestLongPtr() + Dim handle as LongPtr + handle = 123456 +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + IVBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new ObjectVariableNotSetInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + Assert.AreEqual(0, inspectionResults.Count()); + } } } diff --git a/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs index a4ee35d5b0..ebe756d236 100644 --- a/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteCallStatementInspectionTests.cs @@ -38,7 +38,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -70,7 +70,7 @@ public void ObsoleteCallStatement_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -102,7 +102,7 @@ public void ObsoleteCallStatement_DoesNotReturnResult_InstructionSeparator() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -134,7 +134,7 @@ public void ObsoleteCallStatement_ReturnsResult_ColonInComment() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -166,7 +166,7 @@ Call Foo("":"") var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -202,7 +202,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -238,7 +238,7 @@ Sub Goo(arg1 As Integer, arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -271,7 +271,7 @@ Call Foo var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -318,7 +318,7 @@ Sub Goo(arg1 As Integer, arg1 As String) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -373,7 +373,7 @@ Call Foo var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs index 74907d202c..ea2e6ed39f 100644 --- a/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteCommentSyntaxInspectionTests.cs @@ -35,7 +35,7 @@ public void ObsoleteCommentSyntax_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -64,7 +64,7 @@ public void ObsoleteCommentSyntax_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -97,7 +97,7 @@ Dim bar As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -128,7 +128,7 @@ public void ObsoleteCommentSyntax_ReturnsMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -159,7 +159,7 @@ public void ObsoleteCommentSyntax_ReturnsResults_SomeObsoleteCommentSyntax() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -190,7 +190,7 @@ public void ObsoleteCommentSyntax_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -225,7 +225,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -265,7 +265,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateCommentHasContinuation() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -303,7 +303,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -341,7 +341,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveCommentHasContinuation() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -378,7 +378,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCode() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -418,7 +418,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_UpdateComment_LineHasCodeAndCont var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -456,7 +456,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCode() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -494,7 +494,7 @@ public void ObsoleteCommentSyntax_QuickFixWorks_RemoveComment_LineHasCodeAndCont var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -532,7 +532,7 @@ public void ObsoleteCommentSyntax_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs index de71c03965..0afe598313 100644 --- a/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteGlobalInspectionTests.cs @@ -29,7 +29,7 @@ public void ObsoleteGlobal_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -54,7 +54,7 @@ public void ObsoleteGlobal_ReturnsResult_MultipleGlobals() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -78,7 +78,7 @@ public void ObsoleteGlobal_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -103,7 +103,7 @@ public void ObsoleteGlobal_ReturnsResult_SomeConstantsUsed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -128,7 +128,7 @@ public void ObsoleteGlobal_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -157,7 +157,7 @@ public void ObsoleteGlobal_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -189,7 +189,7 @@ public void ObsoleteGlobal_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs index f6ee02e1c8..002f7c237a 100644 --- a/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteLetStatementInspectionTests.cs @@ -41,7 +41,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -77,7 +77,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -112,7 +112,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -148,7 +148,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -184,7 +184,7 @@ Dim var2 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -229,7 +229,7 @@ Dim var2 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -277,7 +277,7 @@ Dim var2 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs b/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs index 0b41f07fcb..6d92c82b02 100644 --- a/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs +++ b/RubberduckTests/Inspections/ObsoleteTypeHintInspectionTests.cs @@ -29,7 +29,7 @@ public void ObsoleteTypeHint_FieldWithLongTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -53,7 +53,7 @@ public void ObsoleteTypeHint_FieldWithIntegerTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -77,7 +77,7 @@ public void ObsoleteTypeHint_FieldWithDoubleTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -101,7 +101,7 @@ public void ObsoleteTypeHint_FieldWithSingleTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -125,7 +125,7 @@ public void ObsoleteTypeHint_FieldWithDecimalTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -149,7 +149,7 @@ public void ObsoleteTypeHint_FieldWithStringTypeHintReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -174,7 +174,7 @@ public void ObsoleteTypeHint_FunctionReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -199,7 +199,7 @@ public void ObsoleteTypeHint_PropertyGetReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -224,7 +224,7 @@ public void ObsoleteTypeHint_ParameterReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -251,7 +251,7 @@ Dim buzz$ var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -278,7 +278,7 @@ Dim bar As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -303,7 +303,7 @@ public void ObsoleteTypeHint_FieldsReturnMultipleResults() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -329,7 +329,7 @@ public void ObsoleteTypeHint_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -358,7 +358,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_LongTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -392,7 +392,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_IntegerTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -426,7 +426,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DoubleTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -460,7 +460,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_SingleTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -494,7 +494,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_DecimalTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -528,7 +528,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Field_StringTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -566,7 +566,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Function_StringTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -604,7 +604,7 @@ public void ObsoleteTypeHint_QuickFixWorks_PropertyGet_StringTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -642,7 +642,7 @@ public void ObsoleteTypeHint_QuickFixWorks_Parameter_StringTypeHint() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -680,7 +680,7 @@ Dim buzz As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -719,7 +719,7 @@ public void ObsoleteTypeHint_IgnoreQuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/OptionBaseInspectionTests.cs b/RubberduckTests/Inspections/OptionBaseInspectionTests.cs index 1656923819..3c5f5811e7 100644 --- a/RubberduckTests/Inspections/OptionBaseInspectionTests.cs +++ b/RubberduckTests/Inspections/OptionBaseInspectionTests.cs @@ -29,7 +29,7 @@ public void OptionBaseOneSpecified_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -52,7 +52,7 @@ public void OptionBaseNotSpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -75,7 +75,7 @@ public void OptionBaseZeroSpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -102,7 +102,7 @@ public void OptionBaseOneSpecified_ReturnsMultipleResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -130,7 +130,7 @@ public void OptionBaseOnePartiallySpecified_ReturnsResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -155,7 +155,7 @@ public void OptionBaseOneSpecified_Ignored_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -184,7 +184,7 @@ public void OptionBaseOneSpecified_IgnoreQuickFixWorks() var module = vbe.Object.VBProjects[0].VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs b/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs index 3424bb0193..dd81f45dd4 100644 --- a/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs +++ b/RubberduckTests/Inspections/OptionExplicitInspectionTests.cs @@ -29,7 +29,7 @@ public void NotAlreadySpecified_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -52,7 +52,7 @@ public void AlreadySpecified_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ public void NotAlreadySpecified_ReturnsMultipleResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -107,7 +107,7 @@ public void PartiallySpecified_ReturnsResults() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -136,7 +136,7 @@ public void NotAlreadySpecified_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -162,7 +162,7 @@ public void OptionExplicit_NoIgnoreQuickFix() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs b/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs index 82b2528af9..ab1aca40e8 100644 --- a/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs +++ b/RubberduckTests/Inspections/ParameterCanBeByValInspectionTests.cs @@ -31,7 +31,7 @@ public void ParameterCanBeByVal_ReturnsResult_PassedByNotSpecified() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -56,7 +56,7 @@ public void ParameterCanBeByVal_ReturnsResult_PassedByRef_Unassigned() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -81,7 +81,7 @@ public void ParameterCanBeByVal_ReturnsResult_Multiple() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -106,7 +106,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_PassedByValExplicitly() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -132,7 +132,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_PassedByRefAndAssigned() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -158,7 +158,7 @@ public void ParameterCanBeByVal_DoesNotReturnResult_BuiltInEventParam() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -183,7 +183,7 @@ public void ParameterCanBeByVal_ReturnsResult_SomeParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -208,7 +208,7 @@ public void GivenArrayParameter_ReturnsNoResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -238,7 +238,7 @@ Sub DoSomethingElse(ByVal bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -268,7 +268,7 @@ Sub DoSomethingElse(ByRef bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -298,7 +298,7 @@ Sub DoSomethingElse(ByVal bar As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -324,7 +324,7 @@ Sub Foo(arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -360,7 +360,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -396,7 +396,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -433,7 +433,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -475,7 +475,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer, ByRef b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -511,7 +511,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -547,7 +547,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -584,7 +584,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -621,7 +621,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer, ByRef arg2 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -652,7 +652,7 @@ public void ParameterCanBeByVal_QuickFixWorks_SubNameStartsWithParamName() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -683,7 +683,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -714,7 +714,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -747,7 +747,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByUnspecified_MultilineParam var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -780,7 +780,7 @@ public void ParameterCanBeByVal_QuickFixWorks_PassedByRef_MultilineParameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -842,7 +842,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByRef b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -906,7 +906,7 @@ Private Sub abc_Foo(ByRef a As Integer, ByVal b As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -944,7 +944,7 @@ Sub Foo(ByRef _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -978,7 +978,7 @@ Debug.Print foo var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1012,7 +1012,7 @@ Debug.Print foo var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1056,7 +1056,7 @@ Debug.Print foo var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs index ee650d3af2..556797cfae 100644 --- a/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ParameterNotUsedInspectionTests.cs @@ -32,7 +32,7 @@ public void ParameterNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -60,7 +60,7 @@ Private Sub Goo(ByVal arg1 as Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -86,7 +86,7 @@ public void ParameterUsed_DoesNotReturnResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -112,7 +112,7 @@ public void ParameterNotUsed_ReturnsResult_SomeParamsUsed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -147,7 +147,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -174,7 +174,7 @@ Private Sub Foo(ByVal arg1 as Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -205,7 +205,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -239,7 +239,7 @@ Private Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs b/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs index a3d4eb17b8..bfaa4db1ca 100644 --- a/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/ProcedureNotUsedInspectionTests.cs @@ -5,6 +5,7 @@ using Rubberduck.Inspections; using Rubberduck.Inspections.QuickFixes; using Rubberduck.Inspections.Resources; +using Rubberduck.Parsing.Symbols; using Rubberduck.Parsing.VBA; using Rubberduck.VBEditor.Application; using Rubberduck.VBEditor.Events; @@ -31,7 +32,7 @@ public void ProcedureNotUsed_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -59,7 +60,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -89,7 +90,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -118,7 +119,7 @@ Private Sub Goo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -153,7 +154,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -166,11 +167,10 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) [TestMethod] [TestCategory("Inspections")] - public void ProcedureNotUsed_DoesNotReturnResult_EventImplementation() + public void ProcedureNotUsed_HandlerIsIgnoredForUnraisedEvent() { //Input - const string inputCode1 = -@"Public Event Foo(ByVal arg1 As Integer, ByVal arg2 As String)"; + const string inputCode1 = @"Public Event Foo(ByVal arg1 As Integer, ByVal arg2 As String)"; const string inputCode2 = @"Private WithEvents abc As Class1 @@ -187,7 +187,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -195,7 +195,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer, ByVal arg2 As String) var inspection = new ProcedureNotUsedInspection(parser.State); var inspectionResults = inspection.GetInspectionResults(); - Assert.AreEqual(0, inspectionResults.Count()); + Assert.AreEqual(0, inspectionResults.Count(result => result.Target.DeclarationType == DeclarationType.Procedure)); } [TestMethod] @@ -215,7 +215,7 @@ public void ProcedureNotUsed_NoResultForClassInitialize() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -243,7 +243,7 @@ public void ProcedureNotUsed_NoResultForCasedClassInitialize() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -271,7 +271,7 @@ public void ProcedureNotUsed_NoResultForClassTerminate() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -299,7 +299,7 @@ public void ProcedureNotUsed_NoResultForCasedClassTerminate() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -326,7 +326,7 @@ Private Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -355,7 +355,7 @@ public void ProcedureNotUsed_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -389,7 +389,7 @@ Private Sub Foo(ByVal arg1 as Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs b/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs index 97e31cb2ae..f5e5b6977e 100644 --- a/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs +++ b/RubberduckTests/Inspections/ProcedureShouldBeFunctionInspectionTests.cs @@ -38,7 +38,7 @@ public void ProcedureShouldBeFunction_ReturnsResult() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -74,7 +74,7 @@ Private Sub Goo(ByRef foo As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -106,7 +106,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnResult_Function() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -137,7 +137,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnResult_SingleByValParam() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -168,7 +168,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnsResult_MultipleByValParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -199,7 +199,7 @@ public void ProcedureShouldBeFunction_DoesNotReturnsResult_MultipleByRefParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -240,7 +240,7 @@ Private Sub IClass1_DoSomething(ByRef a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -280,7 +280,7 @@ Private Sub abc_Foo(ByRef arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -312,7 +312,7 @@ Private Sub Foo(ByRef foo As Boolean) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -352,7 +352,7 @@ public void ProcedureShouldBeFunction_QuickFixWorks() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -392,7 +392,7 @@ public void ProcedureShouldBeFunction_QuickFixWorks_NoAsTypeClauseInParam() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -442,7 +442,7 @@ Sub Goo(ByVal a As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -489,7 +489,7 @@ Sub Goo(ByVal a As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -536,7 +536,7 @@ Sub Goo(ByVal a As String) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -586,7 +586,7 @@ Private Function Foo(ByVal arg1 As Integer) As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -636,7 +636,7 @@ Dim fizz As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -676,7 +676,7 @@ Private Sub Foo(ByRef arg1 As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs b/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs index 3785778ad6..3116e4d646 100644 --- a/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs +++ b/RubberduckTests/Inspections/SelfAssignedDeclarationInspectionTests.cs @@ -34,7 +34,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -63,7 +63,7 @@ Dim b As Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -93,7 +93,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ Dim b As New Collection var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs index 791e0dc2df..beeb63b673 100644 --- a/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/UnassignedVariableUsageInspectionTests.cs @@ -37,7 +37,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -79,7 +79,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -111,7 +111,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -144,7 +144,7 @@ Dim bb As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -172,7 +172,7 @@ Dim foo var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -210,7 +210,7 @@ Dim foo // var module = project.VBComponents[0].CodeModule; // var mockHost = new Mock(); // mockHost.SetupAllProperties(); -// var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); +// var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); // parser.Parse(new CancellationTokenSource()); // if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -250,7 +250,7 @@ Dim bb As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/UndeclaredVariableInspectionTests.cs b/RubberduckTests/Inspections/UndeclaredVariableInspectionTests.cs index ee0de45fda..f2cca9aaec 100644 --- a/RubberduckTests/Inspections/UndeclaredVariableInspectionTests.cs +++ b/RubberduckTests/Inspections/UndeclaredVariableInspectionTests.cs @@ -33,7 +33,7 @@ Debug.Print a var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -64,7 +64,7 @@ Debug.Print a var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -96,7 +96,7 @@ Debug.Print a var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -128,7 +128,7 @@ Debug.Print a var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs b/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs index f909cd5412..2f777c7fe8 100644 --- a/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs +++ b/RubberduckTests/Inspections/UntypedFunctionUsageInspectionTests.cs @@ -40,7 +40,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -72,7 +72,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -107,7 +107,7 @@ Dim str As String var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -147,7 +147,7 @@ Dim str As String var module = project.Object.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); @@ -190,7 +190,7 @@ Dim str As String var module = project.Object.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); GetBuiltInDeclarations().ForEach(d => parser.State.AddDeclaration(d)); diff --git a/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs b/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs index 23e39fc15d..da07768e63 100644 --- a/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs +++ b/RubberduckTests/Inspections/UseMeaningfulNameInspectionTests.cs @@ -151,7 +151,7 @@ Sub Ffffff() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -191,7 +191,7 @@ private void AssertVbaFragmentYieldsExpectedInspectionResultCount(string inputCo var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs b/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs index aefa3ea53b..fb471aed5e 100644 --- a/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableNotAssignedInspectionTests.cs @@ -31,7 +31,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -58,7 +58,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -85,7 +85,7 @@ Dim var1 as String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -114,7 +114,7 @@ Dim var2 as String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -141,7 +141,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -173,7 +173,7 @@ Dim var1 as Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -207,7 +207,7 @@ as _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -240,7 +240,7 @@ Dim var1 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -273,7 +273,7 @@ Dim var1 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -307,7 +307,7 @@ Dim var1 as Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs b/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs index 0ac7dc190f..5cc6e01962 100644 --- a/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableNotUsedInspectionTests.cs @@ -31,7 +31,7 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -58,7 +58,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -90,7 +90,7 @@ Sub Goo(ByVal arg1 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -124,7 +124,7 @@ Sub Goo(ByVal arg1 As Integer) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -151,7 +151,34 @@ Dim var1 As String var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); + + parser.Parse(new CancellationTokenSource()); + if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } + + var inspection = new VariableNotUsedInspection(parser.State); + var inspectionResults = inspection.GetInspectionResults(); + + Assert.IsFalse(inspectionResults.Any()); + } + + [TestMethod] + [TestCategory("Inspections")] + public void VariableNotUsed_DoesNotReturnsResult_UsedInNameStatement() + { + const string inputCode = +@"Sub Foo() + Dim var1 As String + Name ""foo"" As var1 +End Sub"; + + //Arrange + var builder = new MockVbeBuilder(); + IVBComponent component; + var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); + var mockHost = new Mock(); + mockHost.SetupAllProperties(); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -183,7 +210,7 @@ Dim var1 As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -217,7 +244,7 @@ Dim var1 As String var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs b/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs index b3f4eafbbf..1314b92f03 100644 --- a/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs +++ b/RubberduckTests/Inspections/VariableTypeNotDeclaredInspectionTests.cs @@ -30,7 +30,7 @@ public void VariableTypeNotDeclared_ReturnsResult_Parameter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -55,7 +55,7 @@ public void VariableTypeNotDeclared_ReturnsResult_MultipleParams() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -80,7 +80,7 @@ public void VariableTypeNotDeclared_DoesNotReturnResult_Parameter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -105,7 +105,7 @@ public void VariableTypeNotDeclared_ReturnsResult_SomeTypesNotDeclared_Parameter var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -132,7 +132,7 @@ Dim var2 As Date var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -158,7 +158,7 @@ Dim var1 var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -185,7 +185,7 @@ Dim var2 var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -211,7 +211,7 @@ Dim var1 As Integer var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -237,7 +237,7 @@ Sub Foo(arg1) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -268,7 +268,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_Parameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -300,7 +300,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_SubNameContainsParameterName() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -334,7 +334,7 @@ Dim var1 As Variant var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -365,7 +365,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithoutDefaultValue() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -396,7 +396,7 @@ public void VariableTypeNotDeclared_QuickFixWorks_ParameterWithDefaultValue() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -428,7 +428,7 @@ Sub Foo(arg1) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs b/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs index 0ac246921c..c68a9614ed 100644 --- a/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs +++ b/RubberduckTests/Inspections/WriteOnlyPropertyInspectionTests.cs @@ -33,7 +33,7 @@ public void WriteOnlyProperty_ReturnsResult_Let() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -61,7 +61,7 @@ public void WriteOnlyProperty_ReturnsResult_Set() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Property Set Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -120,7 +120,7 @@ public void WriteOnlyProperty_DoesNotReturnsResult_Get() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -154,7 +154,7 @@ Property Set Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -183,7 +183,7 @@ Property Let Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -218,7 +218,7 @@ Property Let Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -255,7 +255,7 @@ Public Property Let Foo(ByVal value As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -292,7 +292,7 @@ Public Property Let Foo(value1, ByVal value2 As Integer, ByRef value3 As Long, v var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -328,7 +328,7 @@ Property Let Foo(value) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Mocks/MockParser.cs b/RubberduckTests/Mocks/MockParser.cs index c7465b97d3..81eafcd3aa 100644 --- a/RubberduckTests/Mocks/MockParser.cs +++ b/RubberduckTests/Mocks/MockParser.cs @@ -28,7 +28,7 @@ public static void ParseString(string inputCode, out QualifiedModuleName qualifi IVBComponent component; var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); qualifiedModuleName = new QualifiedModuleName(component); - var parser = Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Mocks/MockVbeBuilder.cs b/RubberduckTests/Mocks/MockVbeBuilder.cs index ed7776cf53..2072746320 100644 --- a/RubberduckTests/Mocks/MockVbeBuilder.cs +++ b/RubberduckTests/Mocks/MockVbeBuilder.cs @@ -68,8 +68,6 @@ public MockVbeBuilder AddProject(Mock project) _vbe.SetupGet(vbe => vbe.ActiveVBProject).Returns(project.Object); _vbe.SetupGet(vbe => vbe.Version).Returns("7.1"); - - _vbProjects = CreateProjectsMock(); _vbe.SetupGet(m => m.VBProjects).Returns(() => _vbProjects.Object); return this; diff --git a/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs b/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs index 06a5fc6f39..e8dd43842e 100644 --- a/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs +++ b/RubberduckTests/Preprocessing/VBAPreprocessorTests.cs @@ -55,7 +55,7 @@ private string Parse(string code) var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var state = new RubberduckParserState(new Mock().Object); + var state = new RubberduckParserState(vbe.Object); var parser = MockParser.Create(vbe.Object, state); parser.Parse(new CancellationTokenSource()); if (parser.State.Status == ParserState.Error) diff --git a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs index c161e6f605..2b22efc08c 100644 --- a/RubberduckTests/Refactoring/EncapsulateFieldTests.cs +++ b/RubberduckTests/Refactoring/EncapsulateFieldTests.cs @@ -48,7 +48,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -107,7 +107,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -163,7 +163,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -215,7 +215,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -284,7 +284,7 @@ Function Bar() As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -359,7 +359,7 @@ Property Set Foo(ByVal vall As Variant) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -417,7 +417,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -480,7 +480,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -539,7 +539,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -598,7 +598,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -654,7 +654,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -725,7 +725,7 @@ Sub Bar(ByVal name As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -812,7 +812,7 @@ Sub Bar(ByVal v As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -875,7 +875,7 @@ End Property var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -916,7 +916,7 @@ public void EncapsulateField_PresenterIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -946,7 +946,7 @@ public void EncapsulateField_ModelIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -981,7 +981,7 @@ public void GivenNullActiveCodePane_FactoryReturnsNullPresenter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1012,7 +1012,7 @@ public void Presenter_ParameterlessTargetReturnsNullModel() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1043,7 +1043,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1072,7 +1072,7 @@ public void Presenter_Accept_ReturnsModelWithParameterNameChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1103,7 +1103,7 @@ public void Presenter_Reject_ReturnsNull() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1132,7 +1132,7 @@ public void Presenter_Accept_ReturnsModelWithPropertyNameChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1162,7 +1162,7 @@ public void Presenter_Accept_ReturnsModelWithCanImplementLetChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1192,7 +1192,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1222,7 +1222,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1252,7 +1252,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetAllowedForPrimitiveType var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1280,7 +1280,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetNotAllowedForPrimitiveT var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1308,7 +1308,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetAllowedForNonVariantNon var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1336,7 +1336,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetNotAllowedForNonVariant var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1364,7 +1364,7 @@ public void Presenter_Accept_ReturnsModelWithImplementLetAllowedForVariant_NoRef var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1392,7 +1392,7 @@ public void Presenter_Accept_ReturnsModelWithImplementSetAllowedForVariant_NoRef var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1423,7 +1423,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1454,7 +1454,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1485,7 +1485,7 @@ Sub Foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1516,7 +1516,7 @@ Sub foo() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1544,7 +1544,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_PrimitiveType_NoReference() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1573,7 +1573,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_NonPrimitiveTypeNonVariant_NoR var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1602,7 +1602,7 @@ public void Presenter_Accept_DefaultCreateGetOnly_Variant_NoReference() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/ExtractInterfaceTests.cs b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs index 815fea707f..a451bdb18e 100644 --- a/RubberduckTests/Refactoring/ExtractInterfaceTests.cs +++ b/RubberduckTests/Refactoring/ExtractInterfaceTests.cs @@ -55,7 +55,7 @@ End Sub var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -170,7 +170,7 @@ End Property var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -264,7 +264,7 @@ End Function var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -308,7 +308,7 @@ public void ExtractInterfaceRefactoring_IgnoresField() var vbe = builder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -336,7 +336,7 @@ public void ExtractInterfaceRefactoring_NullPresenter_NoChanges() var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -375,7 +375,7 @@ public void ExtractInterfaceRefactoring_NullModel_NoChanges() var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -437,7 +437,7 @@ End Sub var project = vbe.Object.VBProjects[0]; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -475,7 +475,7 @@ public void Presenter_Reject_ReturnsNull() var vbe = builder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -510,7 +510,7 @@ public void Presenter_NullTarget_ReturnsNull() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -540,7 +540,7 @@ public void Presenter_Accept_ReturnsUpdatedModel() var vbe = builder.BuildFromSingleModule(inputCode, ComponentType.ClassModule, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -579,7 +579,7 @@ public void Factory_NoMembersInTarget_ReturnsNull() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -609,7 +609,7 @@ public void Factory_NullSelectionNullReturnsNullPresenter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs index 6ad78bce66..f819adcd81 100644 --- a/RubberduckTests/Refactoring/ImplementInterfaceTests.cs +++ b/RubberduckTests/Refactoring/ImplementInterfaceTests.cs @@ -47,7 +47,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -100,7 +100,7 @@ Public Sub Bar() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -149,7 +149,7 @@ End Sub var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -198,7 +198,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -247,7 +247,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -296,7 +296,7 @@ End Function var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -345,7 +345,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -394,7 +394,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -443,7 +443,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -492,7 +492,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -541,7 +541,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -590,7 +590,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -639,7 +639,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -709,7 +709,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -784,7 +784,7 @@ End Property var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -825,7 +825,7 @@ End Sub var project = vbe.Object.VBProjects[0]; var component = project.VBComponents["Sheet1"]; - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -863,7 +863,7 @@ End Sub var project = vbe.Object.VBProjects[0]; var component = project.VBComponents["Form1"]; - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/IntroduceFieldTests.cs b/RubberduckTests/Refactoring/IntroduceFieldTests.cs index 4611e80da3..543be83147 100644 --- a/RubberduckTests/Refactoring/IntroduceFieldTests.cs +++ b/RubberduckTests/Refactoring/IntroduceFieldTests.cs @@ -45,7 +45,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -87,7 +87,7 @@ Private Function Foo() As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ Private Sub Foo(ByVal buz As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -174,7 +174,7 @@ Private Sub Foo(ByVal buz As Integer) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -220,7 +220,7 @@ Private Sub Foo(ByVal buz As Integer, _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -266,7 +266,7 @@ bap As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -312,7 +312,7 @@ bap As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -358,7 +358,7 @@ bat As Date var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -400,7 +400,7 @@ Private Sub Foo(ByVal buz As Integer, _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -434,7 +434,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -475,7 +475,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -522,7 +522,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -554,7 +554,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/IntroduceParameterTests.cs b/RubberduckTests/Refactoring/IntroduceParameterTests.cs index 649bf11c5b..b5a98d476f 100644 --- a/RubberduckTests/Refactoring/IntroduceParameterTests.cs +++ b/RubberduckTests/Refactoring/IntroduceParameterTests.cs @@ -45,7 +45,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -86,7 +86,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -125,7 +125,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -167,7 +167,7 @@ As _ var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -208,7 +208,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -253,7 +253,7 @@ bap As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -298,7 +298,7 @@ bap As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -343,7 +343,7 @@ bat As Date var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -384,7 +384,7 @@ public void IntroduceParameterRefactoring_MultipleVariablesInStatement_OnOneLine var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -418,7 +418,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -459,7 +459,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -513,7 +513,7 @@ Property Let Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Bool var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -560,7 +560,7 @@ Property Set Foo(ByVal fizz As Boolean, ByVal bar As Integer, ByVal buzz As Vari var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -615,7 +615,7 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -691,7 +691,7 @@ Sub IClass1_fizz(ByVal boo As Boolean, ByVal fizz As Date) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -744,7 +744,7 @@ Dim fizz As Date var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -791,7 +791,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -823,7 +823,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs index abadff1935..855a72f713 100644 --- a/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs +++ b/RubberduckTests/Refactoring/MoveCloserToUsageTests.cs @@ -47,7 +47,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -142,7 +142,7 @@ Dim bar As Boolean var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -189,7 +189,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -236,7 +236,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -284,7 +284,7 @@ Dim bat As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -331,7 +331,7 @@ Dim bar As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -378,7 +378,7 @@ Dim bat As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -425,7 +425,7 @@ Dim bay As Date var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -474,7 +474,7 @@ Dim bar As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -523,7 +523,7 @@ Dim bat As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -572,7 +572,7 @@ Dim bay As Date var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -605,7 +605,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -649,7 +649,7 @@ Private Sub Bar() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -697,7 +697,7 @@ Dim bar As Boolean var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -742,7 +742,7 @@ Sub Baz(ByVal bat As Boolean) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -791,7 +791,7 @@ Sub Baz(ByVal bat As Boolean, ByVal bas As Boolean, ByVal bac As Boolean) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -834,7 +834,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -867,7 +867,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -916,7 +916,7 @@ Private Sub Foo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/RemoveParametersTests.cs b/RubberduckTests/Refactoring/RemoveParametersTests.cs index 078e05e248..d52d52bfda 100644 --- a/RubberduckTests/Refactoring/RemoveParametersTests.cs +++ b/RubberduckTests/Refactoring/RemoveParametersTests.cs @@ -43,7 +43,7 @@ public void RemoveParametersRefactoring_RemoveBothParams() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -86,7 +86,7 @@ public void RemoveParametersRefactoring_RemoveOnlyParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -129,7 +129,7 @@ public void RemoveParametersRefactoring_RemoveFirstParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -172,7 +172,7 @@ public void RemoveParametersRefactoring_RemoveSecondParam() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -225,7 +225,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -278,7 +278,7 @@ Sub goo() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -321,7 +321,7 @@ public void RemoveParametersRefactoring_RemoveLastFromFunction() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -364,7 +364,7 @@ public void RemoveParametersRefactoring_RemoveAllFromFunction() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -417,7 +417,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -469,7 +469,7 @@ Private Sub goo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -514,7 +514,7 @@ public void RemoveParametersRefactoring_RemoveFromGetter() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -556,7 +556,7 @@ Private Property Set Foo(ByVal arg2 As String) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -602,7 +602,7 @@ public void RemoveParametersRefactoring_RemoveFirstParamFromSetter() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -655,7 +655,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -716,7 +716,7 @@ Private Function foo(ByVal b As Integer) As Integer var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -769,7 +769,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -834,7 +834,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -871,7 +871,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromSetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -899,7 +899,7 @@ public void RemoveParametersRefactoring_RemoveLastParamFromLetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -939,7 +939,7 @@ Private Property Set Foo(ByVal arg2 As String) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -988,7 +988,7 @@ Private Property Let Foo(ByVal arg2 As String) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1039,7 +1039,7 @@ Private Sub Goo(ByVal arg1 As Integer) var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1092,7 +1092,7 @@ Foo 1 var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1137,7 +1137,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1182,7 +1182,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveSecond() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1227,7 +1227,7 @@ public void RemoveParametersRefactoring_SignatureOnMultipleLines_RemoveLast() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1272,7 +1272,7 @@ public void RemoveParametersRefactoring_PassTargetIn() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1331,7 +1331,7 @@ End Sub var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1389,7 +1389,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1451,7 +1451,7 @@ Private Sub IClass1_DoSomething(ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1524,7 +1524,7 @@ Private Sub IClass1_DoSomething(ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1588,7 +1588,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1650,7 +1650,7 @@ Private Sub abc_Foo(ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1711,7 +1711,7 @@ Private Sub abc_Foo(ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1784,7 +1784,7 @@ Private Sub abc_Foo(ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1849,7 +1849,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1905,7 +1905,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1936,7 +1936,7 @@ public void RemoveParams_RefactorDeclaration_FailsInvalidTarget() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1982,7 +1982,7 @@ public void RemoveParams_PresenterIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2012,7 +2012,7 @@ public void RemoveParams_ModelIsNull() var module = component.CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2048,7 +2048,7 @@ public void Presenter_Accept_ReturnsModelWithParametersChanged() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2084,7 +2084,7 @@ public void Presenter_Reject_ReturnsNull() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2120,7 +2120,7 @@ public void Presenter_Accept_AutoMarksSingleParamAsRemoved() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2156,7 +2156,7 @@ public void Presenter_ParameterlessTargetReturnsNullModel() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2190,7 +2190,7 @@ public void Factory_NullSelectionNullReturnsNullPresenter() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/RenameTests.cs b/RubberduckTests/Refactoring/RenameTests.cs index 566d338236..34961aea29 100644 --- a/RubberduckTests/Refactoring/RenameTests.cs +++ b/RubberduckTests/Refactoring/RenameTests.cs @@ -42,7 +42,7 @@ public void RenameRefactoring_RenameSub() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -92,7 +92,7 @@ Dim val2 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -139,7 +139,7 @@ public void RenameRefactoring_RenameParameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -188,7 +188,7 @@ public void RenameRefactoring_RenameMulitlinedParameter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -245,7 +245,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -296,7 +296,7 @@ Dim val2 As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -345,7 +345,7 @@ public void RenameRefactoring_RenameParameter_UpdatesReferences() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -416,7 +416,7 @@ Dim d As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -483,7 +483,7 @@ Dim d As Variant var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -550,7 +550,7 @@ Dim d As Variant var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -603,7 +603,7 @@ Private Property Set Goo(ByVal arg1 As Integer, ByVal arg2 As String) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -656,7 +656,7 @@ Private Property Let Goo(ByVal arg1 As String) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -705,7 +705,7 @@ public void RenameRefactoring_RenameFunction() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -766,7 +766,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -813,7 +813,7 @@ public void RenameRefactoring_RefactorWithDeclaration() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -874,7 +874,7 @@ Private Sub IClass1_DoNothing(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -937,7 +937,7 @@ Private Sub abc_Goo(ByVal i As Integer, ByVal s As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1002,7 +1002,7 @@ Private Sub IClass1_DoNothing(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1057,7 +1057,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1090,7 +1090,7 @@ public void Rename_PresenterIsNull() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1127,7 +1127,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1161,7 +1161,7 @@ public void Factory_SelectionIsNull() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1195,7 +1195,7 @@ public void Factory_SelectionIsNotNull_Accept() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1235,7 +1235,7 @@ public void RenameRefactoring_RenameProject() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1282,7 +1282,7 @@ Dim Goo As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1333,7 +1333,7 @@ Dim Goo As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1382,7 +1382,7 @@ public void RenameRefactoring_RenameCodeModule() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/Refactoring/ReorderParametersTests.cs b/RubberduckTests/Refactoring/ReorderParametersTests.cs index 1bfef62b38..7e06d93d60 100644 --- a/RubberduckTests/Refactoring/ReorderParametersTests.cs +++ b/RubberduckTests/Refactoring/ReorderParametersTests.cs @@ -43,7 +43,7 @@ public void ReorderParams_SwapPositions() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -86,7 +86,7 @@ public void ReorderParams_SwapPositions_SignatureContainsParamName() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -137,7 +137,7 @@ Sub Goo() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -180,7 +180,7 @@ public void ReorderParams_RefactorDeclaration() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -216,7 +216,7 @@ public void ReorderParams_RefactorDeclaration_FailsInvalidTarget() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -270,7 +270,7 @@ public void ReorderParams_WithOptionalParam() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -330,7 +330,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -391,7 +391,7 @@ Private Function foo(ByVal b As Integer, ByRef a As Integer) As Integer var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -444,7 +444,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -497,7 +497,7 @@ public void ReorderParametersRefactoring_ReorderNamedParams_Function() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -551,7 +551,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -602,7 +602,7 @@ public void ReorderParametersRefactoring_ReorderGetter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -653,7 +653,7 @@ public void ReorderParametersRefactoring_ReorderLetter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -697,7 +697,7 @@ public void ReorderParametersRefactoring_ReorderSetter() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -734,7 +734,7 @@ public void ReorderParametersRefactoring_ReorderLastParamFromSetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -762,7 +762,7 @@ public void ReorderParametersRefactoring_ReorderLastParamFromLetter_NotAllowed() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -799,7 +799,7 @@ public void ReorderParametersRefactoring_SignatureOnMultipleLines() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -859,7 +859,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -909,7 +909,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -980,7 +980,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1065,7 +1065,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1114,7 +1114,7 @@ public void ReorderParams_MoveOptionalParamBeforeNonOptionalParamFails() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1177,7 +1177,7 @@ End Sub var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1233,7 +1233,7 @@ Private Property Set Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1283,7 +1283,7 @@ Private Property Let Foo(ByVal arg2 As String, ByVal arg1 As Integer, ByVal arg3 var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1321,7 +1321,7 @@ public void ReorderParams_PresenterIsNull() var module = project.VBComponents[0].CodeModule; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1371,7 +1371,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1432,7 +1432,7 @@ Private Sub IClass1_DoSomething(ByVal v2 As String, ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1504,7 +1504,7 @@ Private Sub IClass1_DoSomething(ByVal s As String, ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1568,7 +1568,7 @@ Private Sub IClass1_DoSomething(ByVal b As String, ByVal a As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1624,7 +1624,7 @@ Private Sub IClass1_DoSomething(ByVal a As Integer, ByVal b As String) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1676,7 +1676,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1737,7 +1737,7 @@ Private Sub abc_Foo(ByVal arg2 As String, ByVal arg1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1798,7 +1798,7 @@ Private Sub abc_Foo(ByVal s As String, ByVal i As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1871,7 +1871,7 @@ Private Sub abc_Foo(ByVal v2 As String, ByVal v1 As Integer) var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1913,7 +1913,7 @@ public void Presenter_AcceptDialog_ReordersProcedureWithTwoParameters() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1949,7 +1949,7 @@ public void Presenter_CancelDialogCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -1987,7 +1987,7 @@ public void Presenter_ParameterlessMemberCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2021,7 +2021,7 @@ public void Presenter_SingleParameterMemberCreatesNullModel() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2056,7 +2056,7 @@ Private Sub Foo(ByVal arg1 As Integer, ByVal arg2 As String) var vbe = builder.BuildFromSingleStandardModule(inputCode, out component, selection); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -2086,7 +2086,7 @@ public void Factory_NullSelectionCreatesNullPresenter() var vbe = builder.BuildFromSingleStandardModule(inputCode, out component); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); vbe.Setup(v => v.ActiveCodePane).Returns((ICodePane) null); diff --git a/RubberduckTests/Settings/GeneralSettingsTests.cs b/RubberduckTests/Settings/GeneralSettingsTests.cs index 17bd7e7297..046790995a 100644 --- a/RubberduckTests/Settings/GeneralSettingsTests.cs +++ b/RubberduckTests/Settings/GeneralSettingsTests.cs @@ -23,7 +23,7 @@ private Configuration GetDefaultConfig() Language = new DisplayLanguageSetting("en-US"), AutoSaveEnabled = false, AutoSavePeriod = 10, - Delimiter = '.' + //Delimiter = '.' }; var hotkeySettings = new HotkeySettings() @@ -46,7 +46,7 @@ private Configuration GetNondefaultConfig() Language = new DisplayLanguageSetting("fr-CA"), AutoSaveEnabled = true, AutoSavePeriod = 5, - Delimiter = '/' + //Delimiter = '/' }; var hotkeySettings = new HotkeySettings() @@ -76,8 +76,7 @@ public void SaveConfigWorks() () => Assert.AreEqual(config.UserSettings.GeneralSettings.Language, viewModel.SelectedLanguage), () => Assert.IsTrue(config.UserSettings.HotkeySettings.Settings.SequenceEqual(viewModel.Hotkeys)), () => Assert.AreEqual(config.UserSettings.GeneralSettings.AutoSaveEnabled, viewModel.AutoSaveEnabled), - () => Assert.AreEqual(config.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod), - () => Assert.AreEqual(config.UserSettings.GeneralSettings.Delimiter, (char)viewModel.Delimiter)); + () => Assert.AreEqual(config.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod)); } [TestCategory("Settings")] @@ -93,8 +92,7 @@ public void SetDefaultsWorks() () => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Language, viewModel.SelectedLanguage), () => Assert.IsTrue(defaultConfig.UserSettings.HotkeySettings.Settings.SequenceEqual(viewModel.Hotkeys)), () => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSaveEnabled, viewModel.AutoSaveEnabled), - () => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod), - () => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Delimiter, (char)viewModel.Delimiter)); + () => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod)); } [TestCategory("Settings")] @@ -137,14 +135,14 @@ public void AutoSavePeriodIsSetInCtor() Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod); } - [TestCategory("Settings")] - [TestMethod] - public void DelimiterIsSetInCtor() - { - var defaultConfig = GetDefaultConfig(); - var viewModel = new GeneralSettingsViewModel(defaultConfig, GetOperatingSystemMock().Object); + //[TestCategory("Settings")] + //[TestMethod] + //public void DelimiterIsSetInCtor() + //{ + // var defaultConfig = GetDefaultConfig(); + // var viewModel = new GeneralSettingsViewModel(defaultConfig, GetOperatingSystemMock().Object); - Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Delimiter, (char)viewModel.Delimiter); - } + // Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Delimiter, (char)viewModel.Delimiter); + //} } } diff --git a/RubberduckTests/SourceControl/SourceControlViewModelTests.cs b/RubberduckTests/SourceControl/SourceControlViewModelTests.cs index 235a0d5615..0e303c8990 100644 --- a/RubberduckTests/SourceControl/SourceControlViewModelTests.cs +++ b/RubberduckTests/SourceControl/SourceControlViewModelTests.cs @@ -120,7 +120,7 @@ private void SetupVM() new SettingsView(_settingsVM) }; - _vm = new SourceControlViewViewModel(_vbe.Object, new RubberduckParserState(new Mock().Object), new Mock().Object, _providerFactory.Object, _folderBrowserFactory.Object, + _vm = new SourceControlViewViewModel(_vbe.Object, new RubberduckParserState(_vbe.Object), _providerFactory.Object, _folderBrowserFactory.Object, _configService.Object, views, new Mock().Object); } diff --git a/RubberduckTests/TodoExplorer/TodoExplorerTests.cs b/RubberduckTests/TodoExplorer/TodoExplorerTests.cs index e1b2327d80..8f8cef80fa 100644 --- a/RubberduckTests/TodoExplorer/TodoExplorerTests.cs +++ b/RubberduckTests/TodoExplorer/TodoExplorerTests.cs @@ -32,7 +32,7 @@ public void PicksUpComments() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); @@ -61,7 +61,7 @@ public void PicksUpComments_StrangeCasing() var vbe = builder.AddProject(project.Build()).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); @@ -90,7 +90,7 @@ public void RemoveRemovesComment() var vbe = builder.AddProject(project).Build(); var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe.Object, new RubberduckParserState(vbe.Object)); var vm = new ToDoExplorerViewModel(parser.State, GetConfigService(), GetOperatingSystemMock().Object); diff --git a/RubberduckTests/UnitTesting/DiscoveryTests.cs b/RubberduckTests/UnitTesting/DiscoveryTests.cs index f7beb0cb91..57052a9321 100644 --- a/RubberduckTests/UnitTesting/DiscoveryTests.cs +++ b/RubberduckTests/UnitTesting/DiscoveryTests.cs @@ -29,7 +29,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -50,7 +50,7 @@ public void Discovery_IgnoresNonAnnotatedTestMethods() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -72,7 +72,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -95,7 +95,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -117,7 +117,7 @@ public void Discovery_DiscoversAnnotatedTestInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -143,7 +143,7 @@ public void Discovery_DiscoversAnnotatedTestCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -168,7 +168,7 @@ public void Discovery_IgnoresNonAnnotatedTestInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -190,7 +190,7 @@ public void Discovery_IgnoresNonAnnotatedTestCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -212,7 +212,7 @@ public void Discovery_IgnoresNonAnnotatedTestInitInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -234,7 +234,7 @@ public void Discovery_IgnoresNonAnnotatedTestCleanupInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -257,7 +257,7 @@ public void Discovery_DiscoversAnnotatedModuleInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -283,7 +283,7 @@ public void Discovery_DiscoversAnnotatedModuleCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -308,7 +308,7 @@ public void Discovery_IgnoresNonAnnotatedModuleInitInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -330,7 +330,7 @@ public void Discovery_IgnoresNonAnnotatedModuleCleanupInGivenTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -352,7 +352,7 @@ public void Discovery_IgnoresNonAnnotatedModuleInitInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } @@ -374,7 +374,7 @@ public void Discovery_IgnoresNonAnnotatedModuleCleanupInGivenNonTestModule() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); parser.Parse(new CancellationTokenSource()); if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); } diff --git a/RubberduckTests/UnitTesting/ViewModelTests.cs b/RubberduckTests/UnitTesting/ViewModelTests.cs index bc50f5a97f..2a579fa34c 100644 --- a/RubberduckTests/UnitTesting/ViewModelTests.cs +++ b/RubberduckTests/UnitTesting/ViewModelTests.cs @@ -32,7 +32,7 @@ Public Sub TestMethod1() var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); parser.Parse(new CancellationTokenSource()); @@ -57,7 +57,7 @@ Public Sub TestMethod1() var vbe = builder.Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -89,7 +89,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -116,7 +116,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -143,7 +143,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -182,7 +182,7 @@ Public Sub TestMethod4() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -224,7 +224,7 @@ Public Sub TestMethod3() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -260,7 +260,7 @@ Public Sub TestMethod2() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -290,7 +290,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -319,7 +319,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State); @@ -348,7 +348,7 @@ Public Sub TestMethod1() var vbe = builder.AddProject(project.Build()).Build().Object; var mockHost = new Mock(); mockHost.SetupAllProperties(); - var parser = MockParser.Create(vbe, new RubberduckParserState(new Mock().Object)); + var parser = MockParser.Create(vbe, new RubberduckParserState(vbe)); var model = new TestExplorerModel(vbe, parser.State);