public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.ToList(); var interfaceMemberScopes = declarations.FindInterfaceMembers().Select(m => m.Scope).ToList(); var interfaceImplementationMemberScopes = declarations.FindInterfaceImplementationMembers().Select(m => m.Scope).ToList(); var builtInHandlers = declarations.FindBuiltInEventHandlers(); var parameters = declarations.Where(parameter => parameter.DeclarationType == DeclarationType.Parameter && !(parameter.Context.Parent.Parent is VBAParser.EventStmtContext) && !(parameter.Context.Parent.Parent is VBAParser.DeclareStmtContext)); var unused = parameters.Where(parameter => !parameter.References.Any()).ToList(); var editor = new ActiveCodePaneEditor(_vbe, _wrapperFactory); var quickFixRefactoring = new RemoveParametersRefactoring( new RemoveParametersPresenterFactory(editor, new RemoveParametersDialog(), State, _messageBox), editor); var issues = from issue in unused.Where(parameter => !IsInterfaceMemberParameter(parameter, interfaceMemberScopes) && !builtInHandlers.Contains(parameter.ParentDeclaration)) let isInterfaceImplementationMember = IsInterfaceMemberImplementationParameter(issue, interfaceImplementationMemberScopes) select new ParameterNotUsedInspectionResult(this, issue, ((dynamic)issue.Context).identifier(), issue.QualifiedName, isInterfaceImplementationMember, quickFixRefactoring, State); return(issues.ToList()); }
protected override IEnumerable <IInspectionResult> DoGetInspectionResults() { var declarations = UserDeclarations.ToList(); var interfaceMembers = State.DeclarationFinder.FindAllInterfaceMembers(); var functions = declarations .Where(declaration => ReturningMemberTypes.Contains(declaration.DeclarationType) && !interfaceMembers.Contains(declaration)).ToList(); var unassigned = (from function in functions let isUdt = IsReturningUserDefinedType(function) let inScopeRefs = function.References.Where(r => r.ParentScoping.Equals(function)) where (!isUdt && (!inScopeRefs.Any(r => r.IsAssignment) && !inScopeRefs.Any(reference => IsAssignedByRefArgument(function, reference)))) || (isUdt && !IsUserDefinedTypeAssigned(function)) select function) .ToList(); return(unassigned .Select(issue => new DeclarationInspectionResult(this, string.Format(InspectionResults.NonReturningFunctionInspection, issue.IdentifierName), issue))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.ToList(); var classes = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule).ToList(); var modules = declarations.Where(item => item.DeclarationType == DeclarationType.ProceduralModule).ToList(); var handlers = declarations.Where(item => item.DeclarationType == DeclarationType.Control) .SelectMany(control => declarations.FindEventHandlers(control)).ToList(); var withEventFields = declarations.Where(item => item.DeclarationType == DeclarationType.Variable && item.IsWithEvents); handlers.AddRange(withEventFields.SelectMany(field => declarations.FindEventProcedures(field))); var forms = declarations.Where(item => item.DeclarationType == DeclarationType.ClassModule && item.QualifiedName.QualifiedModuleName.Component.Type == vbext_ComponentType.vbext_ct_MSForm) .ToList(); if (forms.Any()) { handlers.AddRange(forms.SelectMany(form => declarations.FindFormEventHandlers(form))); } var items = declarations .Where(item => !IsIgnoredDeclaration(declarations, item, handlers, classes, modules) && !item.IsInspectionDisabled(AnnotationName)).ToList(); var issues = items.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, issue.Context, issue.QualifiedName.QualifiedModuleName)); issues = DocumentNames.DocumentEventHandlerPrefixes.Aggregate(issues, (current, item) => current.Where(issue => !issue.Description.Contains("'" + item))); return(issues.ToList()); }
protected override IEnumerable <IInspectionResult> DoGetInspectionResults() { var userDeclarations = UserDeclarations.ToList(); var builtinHandlers = State.DeclarationFinder.FindEventHandlers().ToList(); var contextLookup = userDeclarations.Where(decl => decl.Context != null).ToDictionary(decl => decl.Context); var ignored = new HashSet <Declaration>(State.DeclarationFinder.FindAllInterfaceMembers() .Concat(State.DeclarationFinder.FindAllInterfaceImplementingMembers()) .Concat(builtinHandlers) .Concat(userDeclarations.Where(item => item.IsWithEvents))); return(Listener.Contexts .Where(context => context.Context.Parent is VBAParser.SubStmtContext && contextLookup[context.Context.GetChild <VBAParser.ArgContext>()].References .Any(reference => reference.IsAssignment)) .Select(context => contextLookup[(VBAParser.SubStmtContext)context.Context.Parent]) .Where(decl => !IsIgnoringInspectionResultFor(decl, AnnotationName) && !ignored.Contains(decl) && userDeclarations.Where(item => item.IsWithEvents) .All(withEvents => userDeclarations.FindEventProcedures(withEvents) == null) && !builtinHandlers.Contains(decl)) .Select(result => new DeclarationInspectionResult(this, string.Format(InspectionResults.ProcedureCanBeWrittenAsFunctionInspection, result.IdentifierName), result))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { if (ParseTreeResults == null) { Logger.Debug("Aborting GetInspectionResults because ParseTree results were not passed"); return(new InspectionResultBase[] { }); } var subStmts = ParseTreeResults.ArgListsWithOneByRefParam .Where(context => context.Context.Parent is VBAParser.SubStmtContext) .Select(context => (VBAParser.SubStmtContext)context.Context.Parent) .ToList(); var subStmtsNotImplementingInterfaces = subStmts .Where(c => { var declaration = UserDeclarations.SingleOrDefault(d => d.Context == c); if (UserDeclarations.FindInterfaceMembers().Contains(declaration)) { return(false); } var interfaceImplementation = UserDeclarations.FindInterfaceImplementationMembers().SingleOrDefault(m => m.Equals(declaration)); if (interfaceImplementation == null) { return(true); } var interfaceMember = UserDeclarations.FindInterfaceMember(interfaceImplementation); return(interfaceMember == null); }); var subStmtsNotImplementingEvents = subStmts .Where(c => { var declaration = UserDeclarations.SingleOrDefault(d => d.Context == c); if (declaration == null) { return(false); } // rather be safe than sorry return(UserDeclarations.Where(item => item.IsWithEvents) .All(withEvents => UserDeclarations.FindEventProcedures(withEvents) == null) && !State.AllDeclarations.FindBuiltInEventHandlers().Contains(declaration)); }); return(ParseTreeResults.ArgListsWithOneByRefParam .Where(context => context.Context.Parent is VBAParser.SubStmtContext && subStmtsNotImplementingInterfaces.Contains(context.Context.Parent) && subStmtsNotImplementingEvents.Contains(context.Context.Parent)) .Select(context => new ProcedureShouldBeFunctionInspectionResult(this, State, new QualifiedContext <VBAParser.ArgListContext>(context.ModuleName, context.Context as VBAParser.ArgListContext), new QualifiedContext <VBAParser.SubStmtContext>(context.ModuleName, context.Context.Parent as VBAParser.SubStmtContext)))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { if (ParseTreeResults == null) { Logger.Debug("Aborting GetInspectionResults because ParseTree results were not passed"); return(new InspectionResultBase[] { }); } var userDeclarations = UserDeclarations.ToList(); var builtinHandlers = State.DeclarationFinder.FindEventHandlers().ToList(); var contextLookup = userDeclarations.Where(decl => decl.Context != null).ToDictionary(decl => decl.Context); var ignored = new HashSet <Declaration>(State.DeclarationFinder.FindAllInterfaceMembers() .Concat(State.DeclarationFinder.FindAllInterfaceImplementingMembers()) .Concat(builtinHandlers) .Concat(userDeclarations.Where(item => item.IsWithEvents))); return(ParseTreeResults.Where(context => context.Context.Parent is VBAParser.SubStmtContext) .Select(context => contextLookup[(VBAParser.SubStmtContext)context.Context.Parent]) .Where(decl => !IsIgnoringInspectionResultFor(decl, AnnotationName) && !ignored.Contains(decl) && userDeclarations.Where(item => item.IsWithEvents) .All(withEvents => userDeclarations.FindEventProcedures(withEvents) == null) && !builtinHandlers.Contains(decl)) .Select(result => new ProcedureCanBeWrittenAsFunctionInspectionResult( this, State, new QualifiedContext <VBAParser.ArgListContext>(result.QualifiedName, result.Context.GetChild <VBAParser.ArgListContext>(0)), new QualifiedContext <VBAParser.SubStmtContext>(result.QualifiedName, (VBAParser.SubStmtContext)result.Context)) )); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.ToArray(); var issues = new List <ParameterCanBeByValInspectionResult>(); var interfaceDeclarationMembers = declarations.FindInterfaceMembers().ToArray(); var interfaceScopes = declarations.FindInterfaceImplementationMembers().Concat(interfaceDeclarationMembers).Select(s => s.Scope).ToArray(); issues.AddRange(GetResults(declarations, interfaceDeclarationMembers)); var eventMembers = declarations.Where(item => !item.IsBuiltIn && item.DeclarationType == DeclarationType.Event).ToArray(); var formEventHandlerScopes = State.FindFormEventHandlers().Select(handler => handler.Scope).ToArray(); var eventHandlerScopes = State.DeclarationFinder.FindEventHandlers().Concat(declarations.FindUserEventHandlers()).Select(e => e.Scope).ToArray(); var eventScopes = eventMembers.Select(s => s.Scope) .Concat(formEventHandlerScopes) .Concat(eventHandlerScopes) .ToArray(); issues.AddRange(GetResults(declarations, eventMembers)); var declareScopes = declarations.Where(item => item.DeclarationType == DeclarationType.LibraryFunction || item.DeclarationType == DeclarationType.LibraryProcedure) .Select(e => e.Scope) .ToArray(); issues.AddRange(declarations.OfType <ParameterDeclaration>() .Where(declaration => IsIssue(declaration, declarations, declareScopes, eventScopes, interfaceScopes)) .Select(issue => new ParameterCanBeByValInspectionResult(this, State, issue, issue.Context, issue.QualifiedName))); return(issues); }
protected override IEnumerable <IInspectionResult> DoGetInspectionResults() { var settings = _settings.Load(new CodeInspectionSettings()) ?? new CodeInspectionSettings(); var whitelistedNames = settings.WhitelistedIdentifiers.Select(s => s.Identifier).ToArray(); var handlers = State.DeclarationFinder.FindEventHandlers(); var issues = UserDeclarations .Where(declaration => !string.IsNullOrEmpty(declaration.IdentifierName) && !IgnoreDeclarationTypes.Contains(declaration.DeclarationType) && !(declaration.Context is LineNumberLabelContext) && (declaration.ParentDeclaration == null || !IgnoreDeclarationTypes.Contains(declaration.ParentDeclaration.DeclarationType) && !handlers.Contains(declaration.ParentDeclaration)) && !whitelistedNames.Contains(declaration.IdentifierName) && !VariableNameValidator.IsMeaningfulName(declaration.IdentifierName)); return((from issue in issues let props = issue.DeclarationType.HasFlag(DeclarationType.Module) || issue.DeclarationType.HasFlag(DeclarationType.Project) ? new Dictionary <string, string> { { "DisableFixes", "IgnoreOnceQuickFix" } } : null select new DeclarationInspectionResult(this, string.Format(InspectionsUI.IdentifierNameInspectionResultFormat, RubberduckUI.ResourceManager.GetString("DeclarationType_" + issue.DeclarationType, CultureInfo.CurrentUICulture), issue.IdentifierName), issue, properties: props)) .ToList()); }
protected override IEnumerable <IInspectionResult> DoGetInspectionResults() { var declarations = UserDeclarations.ToArray(); var issues = new List <IInspectionResult>(); var interfaceDeclarationMembers = State.DeclarationFinder.FindAllInterfaceMembers().ToArray(); var interfaceScopes = State.DeclarationFinder.FindAllInterfaceImplementingMembers().Concat(interfaceDeclarationMembers).Select(s => s.Scope).ToArray(); issues.AddRange(GetResults(declarations, interfaceDeclarationMembers)); var eventMembers = declarations.Where(item => item.DeclarationType == DeclarationType.Event).ToArray(); var formEventHandlerScopes = State.FindFormEventHandlers().Select(handler => handler.Scope).ToArray(); var eventHandlerScopes = State.DeclarationFinder.FindEventHandlers().Concat(declarations.FindUserEventHandlers()).Select(e => e.Scope).ToArray(); var eventScopes = eventMembers.Select(s => s.Scope) .Concat(formEventHandlerScopes) .Concat(eventHandlerScopes) .ToArray(); issues.AddRange(GetResults(declarations, eventMembers)); var declareScopes = declarations.Where(item => item.DeclarationType == DeclarationType.LibraryFunction || item.DeclarationType == DeclarationType.LibraryProcedure) .Select(e => e.Scope) .ToArray(); issues.AddRange(declarations.OfType <ParameterDeclaration>() .Where(declaration => IsIssue(declaration, declarations, declareScopes, eventScopes, interfaceScopes)) .Select(issue => new DeclarationInspectionResult(this, string.Format(InspectionResults.ParameterCanBeByValInspection, issue.IdentifierName), issue))); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { return(UserDeclarations .Where(declaration => { if (declaration.DeclarationType != DeclarationType.Variable || !new[] { DeclarationType.ClassModule, DeclarationType.ProceduralModule }.Contains(declaration.ParentDeclaration.DeclarationType)) { return false; } var firstReference = declaration.References.FirstOrDefault(); if (firstReference == null || declaration.References.Any(r => r.ParentScoping != firstReference.ParentScoping)) { return false; } var parentDeclaration = ParentDeclaration(firstReference); return parentDeclaration != null && !new[] { DeclarationType.PropertyGet, DeclarationType.PropertyLet, DeclarationType.PropertySet }.Contains(parentDeclaration.DeclarationType); }) .Select(issue => new MoveFieldCloserToUsageInspectionResult(this, issue, State, _wrapperFactory, new MessageBox()))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.ToList(); var interfaceMemberScopes = declarations.FindInterfaceMembers().Select(m => m.Scope).ToList(); var interfaceImplementationMemberScopes = declarations.FindInterfaceImplementationMembers().Select(m => m.Scope).ToList(); var builtInHandlers = State.AllDeclarations.FindBuiltInEventHandlers(); var parameters = declarations.Where(parameter => parameter.DeclarationType == DeclarationType.Parameter && parameter.ParentDeclaration.DeclarationType != DeclarationType.Event && parameter.ParentDeclaration.DeclarationType != DeclarationType.LibraryFunction && parameter.ParentDeclaration.DeclarationType != DeclarationType.LibraryProcedure); var unused = parameters.Where(parameter => !parameter.References.Any()).ToList(); var issues = from issue in unused.Where(parameter => !IsInterfaceMemberParameter(parameter, interfaceMemberScopes) && !builtInHandlers.Contains(parameter.ParentDeclaration)) let isInterfaceImplementationMember = IsInterfaceMemberImplementationParameter(issue, interfaceImplementationMemberScopes) select new ParameterNotUsedInspectionResult(this, issue, ((dynamic)issue.Context).unrestrictedIdentifier(), issue.QualifiedName, isInterfaceImplementationMember, issue.Project.VBE, State, _messageBox); return(issues.ToList()); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var results = UserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Constant && !declaration.References.Any()); return(results.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, ((dynamic)issue.Context).identifier(), issue.QualifiedName.QualifiedModuleName)).Cast <InspectionResultBase>()); }
private Declaration ParentDeclaration(IdentifierReference reference) { var declarationTypes = new[] { DeclarationType.Function, DeclarationType.Procedure, DeclarationType.Property }; return(UserDeclarations.SingleOrDefault(d => reference.ParentScoping.Equals(d) && declarationTypes.Contains(d.DeclarationType) && d.QualifiedName.QualifiedModuleName.Equals(reference.QualifiedModuleName))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var issues = UserDeclarations .Where(declaration => declaration.DeclarationType == DeclarationType.Variable && declaration.Accessibility == Accessibility.Public) .Select(issue => new EncapsulatePublicFieldInspectionResult(this, issue, State)) .ToList(); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var issues = UserDeclarations.Where(declaration => (declaration.DeclarationType == DeclarationType.ClassModule || declaration.DeclarationType == DeclarationType.ProceduralModule) && declaration.Annotations.Count(annotation => annotation.AnnotationType == AnnotationType.Folder) > 1); return(issues.Select(issue => new MultipleFolderAnnotationsInspectionResult(this, issue))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var issues = UserDeclarations .Where(declaration => declaration.DeclarationType == DeclarationType.Project && declaration.IdentifierName.StartsWith("VBAProject")) .Select(issue => new DefaultProjectNameInspectionResult(this, issue, State)) .ToList(); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.Where(declaration => !declaration.IsWithEvents && declaration.DeclarationType == DeclarationType.Variable && declaration.References.All(reference => reference.IsAssignment)); return(declarations.Select(issue => new IdentifierNotUsedInspectionResult(this, issue, ((dynamic)issue.Context).identifier(), issue.QualifiedName.QualifiedModuleName))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { return(UserDeclarations .Where(declaration => declaration.IsSelfAssigned && declaration.IsTypeSpecified() && !ValueTypes.Contains(declaration.AsTypeName) && declaration.DeclarationType == DeclarationType.Variable && declaration.ParentScopeDeclaration != null && declaration.ParentScopeDeclaration.DeclarationType.HasFlag(DeclarationType.Member)) .Select(issue => new SelfAssignedDeclarationInspectionResult(this, issue))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var issues = UserDeclarations .Where(item => item.DeclarationType == DeclarationType.Variable || item.DeclarationType == DeclarationType.Constant) .GroupBy(variable => variable.Context.Parent as ParserRuleContext) .Where(grouping => grouping.Count() > 1) .Select(grouping => new MultipleDeclarationsInspectionResult(this, new QualifiedContext <ParserRuleContext>(grouping.First().QualifiedName.QualifiedModuleName, grouping.Key))); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var multilineParameters = from p in UserDeclarations .Where(item => item.DeclarationType == DeclarationType.Parameter) where p.Context.GetSelection().LineCount > 1 select p; var issues = multilineParameters .Select(param => new MultilineParameterInspectionResult(this, param)); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var assignedByValParameters = UserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Parameter && ((VBAParser.ArgContext)declaration.Context).BYVAL() != null && declaration.References.Any(reference => reference.IsAssignment)); var issues = assignedByValParameters .Select(param => new AssignedByValParameterInspectionResult(this, param)); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var subStmts = State.ArgListsWithOneByRefParam .Where(context => context.Context.Parent is VBAParser.SubStmtContext) .Select(context => (VBAParser.SubStmtContext)context.Context.Parent) .ToList(); var subStmtsNotImplementingInterfaces = subStmts .Where(c => { var declaration = UserDeclarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Procedure && d.IdentifierName == c.identifier().GetText() && d.Context.GetSelection().Equals(c.GetSelection())); var interfaceImplementation = UserDeclarations.FindInterfaceImplementationMembers().SingleOrDefault(m => m.Equals(declaration)); if (interfaceImplementation == null) { return(true); } var interfaceMember = UserDeclarations.FindInterfaceMember(interfaceImplementation); return(interfaceMember == null); }); var subStmtsNotImplementingEvents = subStmts .Where(c => { var declaration = UserDeclarations.SingleOrDefault(d => d.DeclarationType == DeclarationType.Procedure && d.IdentifierName == c.identifier().GetText() && d.Context.GetSelection().Equals(c.GetSelection())); if (declaration == null) { return(false); } // rather be safe than sorry return(UserDeclarations.Where(item => item.IsWithEvents) .All(withEvents => UserDeclarations.FindEventProcedures(withEvents) == null)); }); return(State.ArgListsWithOneByRefParam .Where(context => context.Context.Parent is VBAParser.SubStmtContext && subStmtsNotImplementingInterfaces.Contains(context.Context.Parent) && subStmtsNotImplementingEvents.Contains(context.Context.Parent)) .Select(context => new ProcedureShouldBeFunctionInspectionResult(this, State, new QualifiedContext <VBAParser.ArgListContext>(context.ModuleName, context.Context as VBAParser.ArgListContext), new QualifiedContext <VBAParser.SubStmtContext>(context.ModuleName, context.Context.Parent as VBAParser.SubStmtContext)))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { // Note: This inspection does not find dictionary calls (e.g. foo!bar) since we do not know what the // default member is of a class. var interfaceMembers = UserDeclarations.FindInterfaceMembers().ToList(); var interfaceImplementationMembers = UserDeclarations.FindInterfaceImplementationMembers(); var functions = UserDeclarations.Where(function => function.DeclarationType == DeclarationType.Function).ToList(); var interfaceMemberIssues = GetInterfaceMemberIssues(interfaceMembers); var nonInterfaceFunctions = functions.Except(interfaceMembers.Union(interfaceImplementationMembers)); var nonInterfaceIssues = GetNonInterfaceIssues(nonInterfaceFunctions); return(interfaceMemberIssues.Union(nonInterfaceIssues)); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var issues = UserDeclarations .Where(declaration => declaration.DeclarationType != DeclarationType.ModuleOption && (declaration.IdentifierName.Length < 3 || char.IsDigit(declaration.IdentifierName.Last()) || !declaration.IdentifierName.Any(c => "aeiouy".Any(a => string.Compare(a.ToString(), c.ToString(), StringComparison.OrdinalIgnoreCase) == 0)))) .Select(issue => new UseMeaningfulNameInspectionResult(this, issue, State, _wrapperFactory, _messageBox)) .ToList(); return(issues); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var settings = _settings.Load(new CodeInspectionSettings()) ?? new CodeInspectionSettings(); var whitelistedNames = settings.WhitelistedIdentifiers.Select(s => s.Identifier).ToList(); var hungarians = UserDeclarations .Where(declaration => !whitelistedNames.Contains(declaration.IdentifierName) && TargetDeclarationTypes.Contains(declaration.DeclarationType) && HungarianIdentifierRegex.IsMatch(declaration.IdentifierName)) .Select(issue => new IdentifierNameInspectionResult(this, issue, State, _messageBox, _settings)) .ToList(); return(hungarians); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var declarations = UserDeclarations.ToList(); var interfaceMembers = declarations.FindInterfaceMembers(); var interfaceImplementationMembers = declarations.FindInterfaceImplementationMembers(); var functions = declarations .Where(declaration => ReturningMemberTypes.Contains(declaration.DeclarationType) && !interfaceMembers.Contains(declaration)).ToList(); return(functions .Where(declaration => declaration.References.All(r => !r.IsAssignment)) .Select(issue => new NonReturningFunctionInspectionResult(this, new QualifiedContext <ParserRuleContext>(issue.QualifiedName, issue.Context), interfaceImplementationMembers.Select(m => m.Scope).Contains(issue.Scope), issue))); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var results = UserDeclarations.ToList(); var declarations = from item in results where item.HasTypeHint() // bug: this inspection result only has one value. Why are we passing two in? select new ObsoleteTypeHintInspectionResult(this, string.Format(InspectionsUI.NonReturningFunctionInspectionResultFormat, InspectionsUI.Inspections_DeclarationOf + item.DeclarationType.ToString().ToLower(), item.IdentifierName), new QualifiedContext(item.QualifiedName, item.Context), item); // todo: localize this InspectionResultFormat properly var references = from item in results.SelectMany(d => d.References) where item.HasTypeHint() select new ObsoleteTypeHintInspectionResult(this, string.Format(InspectionsUI.NonReturningFunctionInspectionResultFormat, InspectionsUI.Inspections_UsageOf + item.Declaration.DeclarationType.ToString().ToLower(), item.IdentifierName), new QualifiedContext(item.QualifiedModuleName, item.Context), item.Declaration); return(declarations.Union(references)); }
public override IEnumerable <InspectionResultBase> GetInspectionResults() { var usages = UserDeclarations.Where(declaration => declaration.DeclarationType == DeclarationType.Variable && !UserDeclarations.Any(d => d.DeclarationType == DeclarationType.UserDefinedType && d.IdentifierName == declaration.AsTypeName) && !declaration.IsSelfAssigned && !declaration.References.Any(reference => reference.IsAssignment)) .SelectMany(declaration => declaration.References) .Where(usage => !usage.IsInspectionDisabled(AnnotationName)); foreach (var issue in usages) { yield return(new UnassignedVariableUsageInspectionResult(this, issue.Context, issue.QualifiedModuleName, issue.Declaration)); } }
protected override IEnumerable <IInspectionResult> DoGetInspectionResults() { // Note: This inspection does not find dictionary calls (e.g. foo!bar) since we do not know what the // default member is of a class. var interfaceMembers = UserDeclarations.FindInterfaceMembers().ToList(); var interfaceImplementationMembers = UserDeclarations.FindInterfaceImplementationMembers(); var functions = State.DeclarationFinder .UserDeclarations(DeclarationType.Function) .Where(item => !IsIgnoringInspectionResultFor(item, AnnotationName)) .ToList(); var interfaceMemberIssues = GetInterfaceMemberIssues(interfaceMembers); var nonInterfaceFunctions = functions.Except(interfaceMembers.Union(interfaceImplementationMembers)); var nonInterfaceIssues = GetNonInterfaceIssues(nonInterfaceFunctions); return(interfaceMemberIssues.Union(nonInterfaceIssues)); }
private IEnumerable <IInspectionResult> GetInterfaceMemberIssues(IEnumerable <Declaration> interfaceMembers) { return(from interfaceMember in interfaceMembers let implementationMembers = UserDeclarations.FindInterfaceImplementationMembers(interfaceMember.IdentifierName).ToList() where interfaceMember.DeclarationType == DeclarationType.Function && !IsReturnValueUsed(interfaceMember) && implementationMembers.All(member => !IsReturnValueUsed(member)) let implementationMemberIssues = implementationMembers.Select( implementationMember => Tuple.Create(implementationMember.Context, new QualifiedSelection(implementationMember.QualifiedName.QualifiedModuleName, implementationMember.Selection), implementationMember)) select CreateInspectionResult(this, interfaceMember)); }