public void EvaluateCanExecute(RubberduckParserState state) { foreach (var menu in _menus) { menu.EvaluateCanExecute(state); } }
public RenameRefactoring(IRefactoringPresenterFactory<IRenamePresenter> factory, IActiveCodePaneEditor editor, IMessageBox messageBox, RubberduckParserState state) { _factory = factory; _editor = editor; _messageBox = messageBox; _state = state; }
public RemoveUnusedParameterQuickFix(ParserRuleContext context, QualifiedSelection selection, RemoveParametersRefactoring quickFixRefactoring, RubberduckParserState parseResult) : base(context, selection, InspectionsUI.RemoveUnusedParameterQuickFix) { _quickFixRefactoring = quickFixRefactoring; _parseResult = parseResult; }
private ParseTreeResults GetParseTreeResults(RubberduckParserState state) { var result = new ParseTreeResults(); foreach (var componentTreePair in state.ParseTrees) { /* Need to reinitialize these for each and every ParseTree we process, since the results are aggregated in the instances themselves before moving them into the ParseTreeResults after qualifying them */ var obsoleteCallStatementListener = new ObsoleteCallStatementInspection.ObsoleteCallStatementListener(); var obsoleteLetStatementListener = new ObsoleteLetStatementInspection.ObsoleteLetStatementListener(); var emptyStringLiteralListener = new EmptyStringLiteralInspection.EmptyStringLiteralListener(); var argListWithOneByRefParamListener = new ProcedureCanBeWrittenAsFunctionInspection.ArgListWithOneByRefParamListener(); var malformedAnnotationListener = new MalformedAnnotationInspection.MalformedAnnotationStatementListener(); var combinedListener = new CombinedParseTreeListener(new IParseTreeListener[]{ obsoleteCallStatementListener, obsoleteLetStatementListener, emptyStringLiteralListener, argListWithOneByRefParamListener, malformedAnnotationListener }); ParseTreeWalker.Default.Walk(combinedListener, componentTreePair.Value); result.ArgListsWithOneByRefParam = result.ArgListsWithOneByRefParam.Concat(argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext(componentTreePair.Key, context))); result.EmptyStringLiterals = result.EmptyStringLiterals.Concat(emptyStringLiteralListener.Contexts.Select(context => new QualifiedContext(componentTreePair.Key, context))); result.ObsoleteLetContexts = result.ObsoleteLetContexts.Concat(obsoleteLetStatementListener.Contexts.Select(context => new QualifiedContext(componentTreePair.Key, context))); result.ObsoleteCallContexts = result.ObsoleteCallContexts.Concat(obsoleteCallStatementListener.Contexts.Select(context => new QualifiedContext(componentTreePair.Key, context))); result.MalformedAnnotations = result.MalformedAnnotations.Concat(malformedAnnotationListener.Contexts.Select(context => new QualifiedContext(componentTreePair.Key, context))); } return result; }
public RenameProjectQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState state, ICodePaneWrapperFactory wrapperFactory) : base(context, selection, string.Format(RubberduckUI.Rename_DeclarationType, RubberduckUI.ResourceManager.GetString("DeclarationType_" + DeclarationType.Project, RubberduckUI.Culture))) { _target = target; _state = state; _wrapperFactory = wrapperFactory; }
public ToDoExplorerViewModel(RubberduckParserState state, IGeneralConfigService configService) { _dispatcher = Dispatcher.CurrentDispatcher; _state = state; _configService = configService; _state.StateChanged += _state_StateChanged; }
public ShowParserErrorsCommand(INavigateCommand navigateCommand, RubberduckParserState state, ISearchResultsWindowViewModel viewModel, SearchResultPresenterInstanceManager presenterService) { _navigateCommand = navigateCommand; _state = state; _viewModel = viewModel; _presenterService = presenterService; }
protected InspectionBase(RubberduckParserState state, CodeInspectionSeverity defaultSeverity = CodeInspectionSeverity.Warning) { State = state; _defaultSeverity = defaultSeverity; Severity = _defaultSeverity; _name = GetType().Name; }
public static RubberduckParser Create(VBE vbe, RubberduckParserState state) { var attributeParser = new Mock<IAttributeParser>(); attributeParser.Setup(m => m.Parse(It.IsAny<VBComponent>())) .Returns(() => new Dictionary<Tuple<string, DeclarationType>, Attributes>()); return Create(vbe, state, attributeParser.Object); }
public ParameterNotUsedInspection(VBE vbe, RubberduckParserState state, IMessageBox messageBox) : base(state) { _vbe = vbe; _messageBox = messageBox; _wrapperFactory = new CodePaneWrapperFactory(); }
public ParserState() { _state = new RubberduckParserState(); _attributeParser = new AttributeParser(new ModuleExporter()); _state.StateChanged += _state_StateChanged; }
public EncapsulateFieldModel(RubberduckParserState parseResult, QualifiedSelection selection) { IList<Declaration> declarations = parseResult.AllDeclarations .Where(d => !d.IsBuiltIn && d.DeclarationType == DeclarationType.Variable) .ToList(); TargetDeclaration = declarations.FindVariable(selection); }
public DefaultProjectNameInspectionResult(IInspection inspection, Declaration target, RubberduckParserState parseResult, ICodePaneWrapperFactory wrapperFactory) : base(inspection, target) { _quickFixes = new[] { new RenameProjectQuickFix(target.Context, target.QualifiedSelection, target, parseResult, wrapperFactory), }; }
public RubberduckCommandBar(RubberduckParserState state, VBE vbe, IShowParserErrorsCommand command) { _state = state; _vbe = vbe; _command = command; _state.StateChanged += State_StateChanged; Initialize(); }
public MoveFieldCloserToUsageQuickFix(ParserRuleContext context, QualifiedSelection selection, Declaration target, RubberduckParserState parseResult, ICodePaneWrapperFactory wrapperFactory, IMessageBox messageBox) : base(context, selection, string.Format(InspectionsUI.MoveFieldCloserToUsageInspectionResultFormat, target.IdentifierName)) { _target = target; _parseResult = parseResult; _wrapperFactory = wrapperFactory; _messageBox = messageBox; }
public MoveFieldCloserToUsageInspectionResult(IInspection inspection, Declaration target, RubberduckParserState parseResult, ICodePaneWrapperFactory wrapperFactory, IMessageBox messageBox) : base(inspection, target) { _quickFixes = new[] { new MoveFieldCloserToUsageQuickFix(target.Context, target.QualifiedSelection, target, parseResult, wrapperFactory, messageBox), }; }
public IntroduceFieldRefactoring(RubberduckParserState parserState, IActiveCodePaneEditor editor, IMessageBox messageBox) { _declarations = parserState.AllDeclarations.Where(i => !i.IsBuiltIn && i.DeclarationType == DeclarationType.Variable) .ToList(); _editor = editor; _messageBox = messageBox; }
public void QuickFix(RubberduckParserState parseResult, QualifiedSelection selection) { _model = new RemoveParametersModel(parseResult, selection, new MessageBox()); var target = _model.Declarations.FindTarget(selection, new[] { DeclarationType.Parameter }); // ReSharper disable once PossibleUnintendedReferenceComparison _model.Parameters.Find(param => param.Declaration == target).IsRemoved = true; RemoveParameters(); }
public CodeExplorerViewModel(RubberduckParserState state, INavigateCommand navigateCommand) { _state = state; _navigateCommand = navigateCommand; _state.StateChanged += ParserState_StateChanged; _state.ModuleStateChanged += ParserState_ModuleStateChanged; _refreshCommand = new DelegateCommand(ExecuteRefreshCommand); }
public FindAllReferencesCommand(INavigateCommand navigateCommand, IMessageBox messageBox, RubberduckParserState state, VBE vbe, ISearchResultsWindowViewModel viewModel, SearchResultPresenterInstanceManager presenterService) { _navigateCommand = navigateCommand; _messageBox = messageBox; _state = state; _vbe = vbe; _viewModel = viewModel; _presenterService = presenterService; }
public UseMeaningfulNameInspectionResult(IInspection inspection, Declaration target, RubberduckParserState parserState, ICodePaneWrapperFactory wrapperFactory, IMessageBox messageBox) : base(inspection, target) { _quickFixes = new CodeInspectionQuickFix[] { new RenameDeclarationQuickFix(target.Context, target.QualifiedSelection, target, parserState, wrapperFactory, messageBox), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), }; }
public RenameModel(VBE vbe, RubberduckParserState parseResult, QualifiedSelection selection, IMessageBox messageBox) { _vbe = vbe; _parseResult = parseResult; _declarations = parseResult.AllDeclarations.ToList(); _selection = selection; _messageBox = messageBox; AcquireTarget(out _target, Selection); }
public ReorderParametersModel(RubberduckParserState parseResult, QualifiedSelection selection, IMessageBox messageBox) { _parseResult = parseResult; _declarations = parseResult.AllUserDeclarations; _messageBox = messageBox; AcquireTarget(selection); Parameters = new List<Parameter>(); LoadParameters(); }
public ParameterNotUsedInspectionResult(IInspection inspection, Declaration target, ParserRuleContext context, QualifiedMemberName qualifiedName, bool isInterfaceImplementation, RemoveParametersRefactoring refactoring, RubberduckParserState parseResult) : base(inspection, qualifiedName.QualifiedModuleName, context, target) { _quickFixes = isInterfaceImplementation ? new CodeInspectionQuickFix[] {} : new CodeInspectionQuickFix[] { new RemoveUnusedParameterQuickFix(Context, QualifiedSelection, refactoring, parseResult), new IgnoreOnceQuickFix(Context, QualifiedSelection, Inspection.AnnotationName), }; }
public RubberduckParser(VBE vbe, RubberduckParserState state, IAttributeParser attributeParser) { _resolverTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_central.Token); _vbe = vbe; _state = state; _attributeParser = attributeParser; _comReflector = new ReferencedDeclarationsCollector(); state.ParseRequest += ReparseRequested; state.StateChanged += StateOnStateChanged; }
public ChangeProcedureToFunction(RubberduckParserState state, QualifiedContext<VBAParser.ArgListContext> argListQualifiedContext, QualifiedContext<VBAParser.SubStmtContext> subStmtQualifiedContext, QualifiedSelection selection) : base(subStmtQualifiedContext.Context, selection, InspectionsUI.ProcedureShouldBeFunctionInspectionQuickFix) { _state = state; _argListQualifiedContext = argListQualifiedContext; _subStmtQualifiedContext = subStmtQualifiedContext; _argQualifiedContext = new QualifiedContext<VBAParser.ArgContext>(_argListQualifiedContext.ModuleName, _argListQualifiedContext.Context.arg() .First(a => a.BYREF() != null || (a.BYREF() == null && a.BYVAL() == null))); }
public ProcedureShouldBeFunctionInspectionResult(IInspection inspection, RubberduckParserState state, QualifiedContext<VBAParser.ArgListContext> argListQualifiedContext, QualifiedContext<VBAParser.SubStmtContext> subStmtQualifiedContext) : base(inspection, subStmtQualifiedContext.ModuleName, subStmtQualifiedContext.Context.ambiguousIdentifier()) { _target = state.AllUserDeclarations.Single(declaration => declaration.DeclarationType == DeclarationType.Procedure && declaration.Context == subStmtQualifiedContext.Context); _quickFixes = new[] { new ChangeProcedureToFunction(state, argListQualifiedContext, subStmtQualifiedContext, QualifiedSelection), }; }
private string Parse(string code) { var builder = new MockVbeBuilder(); VBComponent component; var vbe = builder.BuildFromSingleStandardModule(code, out component); var mockHost = new Mock<IHostApplication>(); mockHost.SetupAllProperties(); var state = new RubberduckParserState(); var parser = MockParser.Create(vbe.Object, state); parser.Parse(); if (parser.State.Status == ParserState.Error) { Assert.Inconclusive("Parser Error"); } var tree = state.GetParseTree(component); var parsed = tree.GetText(); var withoutEOF = parsed.Substring(0, parsed.Length - 5); return withoutEOF; }
public DefaultInspector(IEnumerable<IInspection> inspections, RubberduckParserState state) { _inspections = inspections.ToList(); if (_inspections.All(i => i.Name != nameof(ParameterNotUsedInspection))) { _inspections.Add(new ParameterNotUsedInspection(null, state, null)); } if (_inspections.All(i => i.Name != nameof(UseMeaningfulNameInspection))) { var settings = new Mock<IPersistanceService<CodeInspectionSettings>>(); settings.Setup(s => s.Load(It.IsAny<CodeInspectionSettings>())) .Returns(new CodeInspectionSettings()); _inspections.Add(new UseMeaningfulNameInspection(null, state, settings.Object)); } }
public async Task<IList<ICodeInspectionResult>> FindIssuesAsync(RubberduckParserState state, CancellationToken token) { if (state == null || !state.AllUserDeclarations.Any()) { return new ICodeInspectionResult[] { }; } await Task.Yield(); state.OnStatusMessageUpdate(RubberduckUI.CodeInspections_Inspecting); UpdateInspectionSeverity(); //OnReset(); var allIssues = new ConcurrentBag<ICodeInspectionResult>(); var inspections = _inspections.Where(inspection => inspection.Severity != CodeInspectionSeverity.DoNotShow) .Select(inspection => new Task(() => { token.ThrowIfCancellationRequested(); var inspectionResults = inspection.GetInspectionResults(); var results = inspectionResults as IList<InspectionResultBase> ?? inspectionResults.ToList(); if (results.Any()) { //OnIssuesFound(results); foreach (var inspectionResult in results) { allIssues.Add(inspectionResult); } } })).ToArray(); foreach (var inspection in inspections) { inspection.Start(); } Task.WaitAll(inspections); state.OnStatusMessageUpdate(RubberduckUI.ResourceManager.GetString("ParserState_" + state.Status)); // should be "Ready" return allIssues.ToList(); }
public ParserStateManager(RubberduckParserState state) : base(state) { }