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));
}
