Skip to content

Commit e7590af

Browse files
MDoernerMDoerner
committed
Add base classes for declaration inspections that use global information
The information gets passed down to the method determining whether a declaration is a result. This means that the signatures of the methods are different from the the other base classes. So, these for a second hierarchy. This also changes the base classes to also look at the QMNs of user projects. Finally, this makes the final declaration inspections use the base classes.
1 parent e096043 commit e7590af

8 files changed

+280
-188
lines changed

‎Rubberduck.CodeAnalysis/Inspections/Abstract/DeclarationInspectionBaseBase.cs

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
3434
var finder = DeclarationFinderProvider.DeclarationFinder;
3535

3636
var results = new List<IInspectionResult>();
37-
foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
37+
foreach (var moduleDeclaration in finder.UserDeclarations(DeclarationType.Module))
3838
{
3939
if (moduleDeclaration == null)
4040
{
@@ -45,6 +45,17 @@ protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
4545
results.AddRange(DoGetInspectionResults(module, finder));
4646
}
4747

48+
foreach (var projectDeclaration in finder.UserDeclarations(DeclarationType.Project))
49+
{
50+
if (projectDeclaration == null)
51+
{
52+
continue;
53+
}
54+
55+
var module = projectDeclaration.QualifiedModuleName;
56+
results.AddRange(DoGetInspectionResults(module, finder));
57+
}
58+
4859
return results;
4960
}
5061

‎Rubberduck.CodeAnalysis/Inspections/Abstract/DeclarationInspectionUsingGlobalInformationBase.cs

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
using System.Collections.Generic;
2+
using System.Linq;
3+
using Rubberduck.Inspections.Results;
4+
using Rubberduck.Parsing.Inspections.Abstract;
5+
using Rubberduck.Parsing.Symbols;
6+
using Rubberduck.Parsing.VBA;
7+
using Rubberduck.Parsing.VBA.DeclarationCaching;
8+
using Rubberduck.VBEditor;
9+
10+
namespace Rubberduck.Inspections.Abstract
11+
{
12+
public abstract class DeclarationInspectionUsingGlobalInformationBase<TGlobalInfo> : DeclarationInspectionUsingGlobalInformationBaseBase<TGlobalInfo>
13+
{
14+
protected DeclarationInspectionUsingGlobalInformationBase(RubberduckParserState state, params DeclarationType[] relevantDeclarationTypes)
15+
: base(state, relevantDeclarationTypes)
16+
{}
17+
18+
protected DeclarationInspectionUsingGlobalInformationBase(RubberduckParserState state, DeclarationType[] relevantDeclarationTypes, DeclarationType[] excludeDeclarationTypes)
19+
: base(state, relevantDeclarationTypes, excludeDeclarationTypes)
20+
{}
21+
22+
protected abstract bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder, TGlobalInfo globalInfo);
23+
protected abstract string ResultDescription(Declaration declaration);
24+
25+
protected virtual ICollection<string> DisabledQuickFixes(Declaration declaration) => new List<string>();
26+
27+
protected override IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder, TGlobalInfo globalInfo)
28+
{
29+
var objectionableDeclarations = RelevantDeclarationsInModule(module, finder)
30+
.Where(declaration => IsResultDeclaration(declaration, finder, globalInfo));
31+
32+
return objectionableDeclarations
33+
.Select(InspectionResult)
34+
.ToList();
35+
}
36+
37+
protected virtual IInspectionResult InspectionResult(Declaration declaration)
38+
{
39+
return new DeclarationInspectionResult(
40+
this,
41+
ResultDescription(declaration),
42+
declaration,
43+
disabledQuickFixes: DisabledQuickFixes(declaration));
44+
}
45+
}
46+
47+
public abstract class DeclarationInspectionUsingGlobalInformationBase<TGlobalInfo,TProperties> : DeclarationInspectionUsingGlobalInformationBaseBase<TGlobalInfo>
48+
{
49+
protected DeclarationInspectionUsingGlobalInformationBase(RubberduckParserState state, params DeclarationType[] relevantDeclarationTypes)
50+
: base(state, relevantDeclarationTypes)
51+
{}
52+
53+
protected DeclarationInspectionUsingGlobalInformationBase(RubberduckParserState state, DeclarationType[] relevantDeclarationTypes, DeclarationType[] excludeDeclarationTypes)
54+
: base(state, relevantDeclarationTypes, excludeDeclarationTypes)
55+
{}
56+
57+
protected abstract (bool isResult, TProperties properties) IsResultDeclarationWithAdditionalProperties(Declaration declaration, DeclarationFinder finder, TGlobalInfo globalInformation);
58+
protected abstract string ResultDescription(Declaration declaration, TProperties properties);
59+
60+
protected virtual ICollection<string> DisabledQuickFixes(Declaration declaration, TProperties properties) => new List<string>();
61+
62+
protected override IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder, TGlobalInfo globalInformation)
63+
{
64+
var objectionableDeclarationsWithAdditionalProperties = RelevantDeclarationsInModule(module, finder)
65+
.Select(declaration => (declaration, IsResultDeclarationWithAdditionalProperties(declaration, finder, globalInformation)))
66+
.Where(tpl => tpl.Item2.isResult)
67+
.Select(tpl => (tpl.declaration, tpl.Item2.properties));
68+
69+
return objectionableDeclarationsWithAdditionalProperties
70+
.Select(tpl => InspectionResult(tpl.declaration, tpl.properties))
71+
.ToList();
72+
}
73+
74+
protected virtual IInspectionResult InspectionResult(Declaration declaration, TProperties properties)
75+
{
76+
return new DeclarationInspectionResult<TProperties>(
77+
this,
78+
ResultDescription(declaration, properties),
79+
declaration,
80+
properties: properties,
81+
disabledQuickFixes: DisabledQuickFixes(declaration, properties));
82+
}
83+
}
84+
}

‎Rubberduck.CodeAnalysis/Inspections/Abstract/DeclarationInspectionUsingGlobalInformationBaseBase.cs

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
using System.Collections.Generic;
2+
using System.Linq;
3+
using Rubberduck.Parsing.Inspections.Abstract;
4+
using Rubberduck.Parsing.Symbols;
5+
using Rubberduck.Parsing.VBA;
6+
using Rubberduck.Parsing.VBA.DeclarationCaching;
7+
using Rubberduck.VBEditor;
8+
9+
namespace Rubberduck.Inspections.Abstract
10+
{
11+
public abstract class DeclarationInspectionUsingGlobalInformationBaseBase<T> : InspectionBase
12+
{
13+
protected readonly DeclarationType[] RelevantDeclarationTypes;
14+
protected readonly DeclarationType[] ExcludeDeclarationTypes;
15+
16+
protected DeclarationInspectionUsingGlobalInformationBaseBase(RubberduckParserState state, params DeclarationType[] relevantDeclarationTypes)
17+
: base(state)
18+
{
19+
RelevantDeclarationTypes = relevantDeclarationTypes;
20+
ExcludeDeclarationTypes = new DeclarationType[0];
21+
}
22+
23+
protected DeclarationInspectionUsingGlobalInformationBaseBase(RubberduckParserState state, DeclarationType[] relevantDeclarationTypes, DeclarationType[] excludeDeclarationTypes)
24+
: base(state)
25+
{
26+
RelevantDeclarationTypes = relevantDeclarationTypes;
27+
ExcludeDeclarationTypes = excludeDeclarationTypes;
28+
}
29+
30+
protected abstract IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder, T globalInformation);
31+
protected abstract T GlobalInformation(DeclarationFinder finder);
32+
33+
protected virtual T GlobalInformation(QualifiedModuleName module, DeclarationFinder finder)
34+
{
35+
return GlobalInformation(finder);
36+
}
37+
38+
protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
39+
{
40+
var finder = DeclarationFinderProvider.DeclarationFinder;
41+
var globalInformation = GlobalInformation(finder);
42+
43+
var results = new List<IInspectionResult>();
44+
foreach (var moduleDeclaration in finder.UserDeclarations(DeclarationType.Module))
45+
{
46+
if (moduleDeclaration == null)
47+
{
48+
continue;
49+
}
50+
51+
var module = moduleDeclaration.QualifiedModuleName;
52+
results.AddRange(DoGetInspectionResults(module, finder, globalInformation));
53+
}
54+
55+
foreach (var projectDeclaration in finder.UserDeclarations(DeclarationType.Project))
56+
{
57+
if (projectDeclaration == null)
58+
{
59+
continue;
60+
}
61+
62+
var module = projectDeclaration.QualifiedModuleName;
63+
results.AddRange(DoGetInspectionResults(module, finder, globalInformation));
64+
}
65+
66+
return results;
67+
}
68+
69+
protected virtual IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
70+
{
71+
var finder = DeclarationFinderProvider.DeclarationFinder;
72+
var globalInformation = GlobalInformation(module, finder);
73+
return DoGetInspectionResults(module, finder, globalInformation);
74+
}
75+
76+
protected virtual IEnumerable<Declaration> RelevantDeclarationsInModule(QualifiedModuleName module, DeclarationFinder finder)
77+
{
78+
var potentiallyRelevantDeclarations = RelevantDeclarationTypes.Length == 0
79+
? finder.Members(module)
80+
: RelevantDeclarationTypes
81+
.SelectMany(declarationType => finder.Members(module, declarationType))
82+
.Distinct();
83+
return potentiallyRelevantDeclarations
84+
.Where(declaration => !ExcludeDeclarationTypes.Contains(declaration.DeclarationType));
85+
}
86+
}
87+
}

‎Rubberduck.CodeAnalysis/Inspections/Concrete/DefaultProjectNameInspection.cs

Lines changed: 0 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -21,25 +21,6 @@ public DefaultProjectNameInspection(RubberduckParserState state)
2121
: base(state, DeclarationType.Project)
2222
{}
2323

24-
protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
25-
{
26-
var finder = DeclarationFinderProvider.DeclarationFinder;
27-
28-
var results = new List<IInspectionResult>();
29-
foreach (var projectDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Project))
30-
{
31-
if (projectDeclaration == null)
32-
{
33-
continue;
34-
}
35-
36-
var module = projectDeclaration.QualifiedModuleName;
37-
results.AddRange(DoGetInspectionResults(module, finder));
38-
}
39-
40-
return results;
41-
}
42-
4324
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder)
4425
{
4526
return declaration.IdentifierName.StartsWith("VBAProject");

‎Rubberduck.CodeAnalysis/Inspections/Concrete/HungarianNotationInspection.cs

Lines changed: 8 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -4,13 +4,10 @@
44
using Rubberduck.Common;
55
using Rubberduck.Inspections.Abstract;
66
using Rubberduck.Inspections.Inspections.Extensions;
7-
using Rubberduck.Inspections.Results;
8-
using Rubberduck.Parsing.Inspections.Abstract;
97
using Rubberduck.Parsing.Symbols;
108
using Rubberduck.Parsing.VBA;
119
using Rubberduck.Parsing.VBA.DeclarationCaching;
1210
using Rubberduck.SettingsProvider;
13-
using Rubberduck.VBEditor;
1411

1512
namespace Rubberduck.Inspections.Concrete
1613
{
@@ -46,9 +43,9 @@ namespace Rubberduck.Inspections.Concrete
4643
/// End Function
4744
/// ]]>
4845
/// </example>
49-
public sealed class HungarianNotationInspection : InspectionBase
46+
public sealed class HungarianNotationInspection : DeclarationInspectionUsingGlobalInformationBase<List<string>>
5047
{
51-
private static readonly List<DeclarationType> TargetDeclarationTypes = new List<DeclarationType>
48+
private static readonly DeclarationType[] TargetDeclarationTypes = new []
5249
{
5350
DeclarationType.Parameter,
5451
DeclarationType.Constant,
@@ -64,7 +61,7 @@ public sealed class HungarianNotationInspection : InspectionBase
6461
DeclarationType.Variable
6562
};
6663

67-
private static readonly List<DeclarationType> IgnoredProcedureTypes = new List<DeclarationType>
64+
private static readonly DeclarationType[] IgnoredProcedureTypes = new []
6865
{
6966
DeclarationType.LibraryFunction,
7067
DeclarationType.LibraryProcedure
@@ -73,70 +70,27 @@ public sealed class HungarianNotationInspection : InspectionBase
7370
private readonly IConfigurationService<CodeInspectionSettings> _settings;
7471

7572
public HungarianNotationInspection(RubberduckParserState state, IConfigurationService<CodeInspectionSettings> settings)
76-
: base(state)
73+
: base(state, TargetDeclarationTypes, IgnoredProcedureTypes)
7774
{
7875
_settings = settings;
7976
}
8077

81-
protected override IEnumerable<IInspectionResult> DoGetInspectionResults()
78+
protected override List<string> GlobalInformation(DeclarationFinder finder)
8279
{
83-
var finder = DeclarationFinderProvider.DeclarationFinder;
8480
var settings = _settings.Read();
85-
var whitelistedNames = settings.WhitelistedIdentifiers
81+
return settings.WhitelistedIdentifiers
8682
.Select(s => s.Identifier)
8783
.ToList();
88-
89-
var results = new List<IInspectionResult>();
90-
foreach (var moduleDeclaration in State.DeclarationFinder.UserDeclarations(DeclarationType.Module))
91-
{
92-
if (moduleDeclaration == null)
93-
{
94-
continue;
95-
}
96-
97-
var module = moduleDeclaration.QualifiedModuleName;
98-
results.AddRange(DoGetInspectionResults(module, finder, whitelistedNames));
99-
}
100-
101-
return results;
102-
}
103-
104-
private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module)
105-
{
106-
var finder = DeclarationFinderProvider.DeclarationFinder;
107-
var settings = _settings.Read();
108-
var whitelistedNames = settings.WhitelistedIdentifiers
109-
.Select(s => s.Identifier)
110-
.ToList();
111-
return DoGetInspectionResults(module, finder, whitelistedNames);
112-
}
113-
114-
private IEnumerable<IInspectionResult> DoGetInspectionResults(QualifiedModuleName module, DeclarationFinder finder, List<string> whitelistedNames)
115-
{
116-
var objectionableDeclarations = RelevantDeclarationsInModule(module, finder)
117-
.Where(declaration => IsResultDeclaration(declaration, whitelistedNames));
118-
119-
return objectionableDeclarations
120-
.Select(InspectionResult)
121-
.ToList();
12284
}
12385

124-
private static bool IsResultDeclaration(Declaration declaration, ICollection<string> whitelistedNames)
86+
protected override bool IsResultDeclaration(Declaration declaration, DeclarationFinder finder, List<string> whitelistedNames)
12587
{
12688
return !whitelistedNames.Contains(declaration.IdentifierName)
12789
&& !IgnoredProcedureTypes.Contains(declaration.ParentDeclaration.DeclarationType)
12890
&& declaration.IdentifierName.TryMatchHungarianNotationCriteria(out _);
12991
}
13092

131-
private IInspectionResult InspectionResult(Declaration declaration)
132-
{
133-
return new DeclarationInspectionResult(
134-
this,
135-
ResultDescription(declaration),
136-
declaration);
137-
}
138-
139-
private static string ResultDescription(Declaration declaration)
93+
protected override string ResultDescription(Declaration declaration)
14094
{
14195
var declarationType = declaration.DeclarationType.ToLocalizedString();
14296
var declarationName = declaration.IdentifierName;
@@ -145,14 +99,5 @@ private static string ResultDescription(Declaration declaration)
14599
declarationType,
146100
declarationName);
147101
}
148-
149-
private IEnumerable<Declaration> RelevantDeclarationsInModule(QualifiedModuleName module, DeclarationFinder finder)
150-
{
151-
var potentiallyRelevantDeclarations = TargetDeclarationTypes
152-
.SelectMany(declarationType => finder.Members(module, declarationType))
153-
.Distinct();
154-
return potentiallyRelevantDeclarations
155-
.Where(declaration => !IgnoredProcedureTypes.Contains(declaration.DeclarationType));
156-
}
157102
}
158103
}

0 commit comments

Comments
 (0)