2
// ParameterCouldBeDeclaredWithBaseTypeIssue.cs
5
// Simon Lindgren <simon.n.lindgren@gmail.com>
7
// Copyright (c) 2012 Simon Lindgren
9
// Permission is hereby granted, free of charge, to any person obtaining a copy
10
// of this software and associated documentation files (the "Software"), to deal
11
// in the Software without restriction, including without limitation the rights
12
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13
// copies of the Software, and to permit persons to whom the Software is
14
// furnished to do so, subject to the following conditions:
16
// The above copyright notice and this permission notice shall be included in
17
// all copies or substantial portions of the Software.
19
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26
using System.Collections.Generic;
27
using ICSharpCode.NRefactory.TypeSystem;
28
using ICSharpCode.NRefactory.Semantics;
31
using ICSharpCode.NRefactory.CSharp.Resolver;
32
using ICSharpCode.NRefactory.TypeSystem.Implementation;
33
using System.Diagnostics;
35
namespace ICSharpCode.NRefactory.CSharp.Refactoring
37
[IssueDescription("A parameter can be demoted to base class",
38
Description = "Finds parameters that can be demoted to a base class.",
39
Category = IssueCategories.Opportunities,
40
Severity = Severity.Suggestion,
41
SuppressMessageCategory="Microsoft.Design",
42
SuppressMessageCheckId="CA1011:ConsiderPassingBaseTypesAsParameters"
44
public class ParameterCanBeDemotedIssue : ICodeIssueProvider
48
public ParameterCanBeDemotedIssue() : this (true)
52
public ParameterCanBeDemotedIssue(bool tryResolve)
54
this.tryResolve = tryResolve;
57
#region ICodeIssueProvider implementation
58
public IEnumerable<CodeIssue> GetIssues(BaseRefactoringContext context)
60
// var sw = new Stopwatch();
62
var gatherer = new GatherVisitor(context, tryResolve);
63
var issues = gatherer.GetIssues();
65
// Console.WriteLine("Elapsed time in ParameterCanBeDemotedIssue: {0} (Checked types: {3, 4} Qualified for resolution check: {5, 4} Members with issues: {4, 4} Method bodies resolved: {2, 4} File: '{1}')",
66
// sw.Elapsed, context.UnresolvedFile.FileName, gatherer.MethodResolveCount, gatherer.TypesChecked, gatherer.MembersWithIssues, gatherer.TypeResolveCount);
71
class GatherVisitor : GatherVisitorBase<ParameterCanBeDemotedIssue>
75
public GatherVisitor(BaseRefactoringContext context, bool tryResolve) : base (context)
77
this.tryResolve = tryResolve;
80
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration)
82
methodDeclaration.Attributes.AcceptVisitor(this);
83
if (HasEntryPointSignature(methodDeclaration))
85
var eligibleParameters = methodDeclaration.Parameters
86
.Where(p => p.ParameterModifier != ParameterModifier.Out && p.ParameterModifier != ParameterModifier.Ref)
88
if (eligibleParameters.Count == 0)
90
var declarationResolveResult = ctx.Resolve(methodDeclaration) as MemberResolveResult;
91
if (declarationResolveResult == null)
93
var member = declarationResolveResult.Member;
94
if (member.IsOverride || member.IsOverridable || member.ImplementedInterfaceMembers.Any())
97
var collector = new TypeCriteriaCollector(ctx);
98
methodDeclaration.AcceptVisitor(collector);
100
foreach (var parameter in eligibleParameters) {
101
ProcessParameter(parameter, methodDeclaration.Body, collector);
105
bool HasEntryPointSignature(MethodDeclaration methodDeclaration)
107
if (!methodDeclaration.Modifiers.HasFlag(Modifiers.Static))
109
var returnType = ctx.Resolve(methodDeclaration.ReturnType).Type;
110
if (!returnType.IsKnownType(KnownTypeCode.Int32) && !returnType.IsKnownType(KnownTypeCode.Void))
112
var parameterCount = methodDeclaration.Parameters.Count;
113
if (parameterCount == 0)
115
if (parameterCount != 1)
117
var parameterType = ctx.Resolve(methodDeclaration.Parameters.First()).Type as ArrayType;
118
if (parameterType == null || !parameterType.ElementType.IsKnownType(KnownTypeCode.String))
123
void ProcessParameter(ParameterDeclaration parameter, AstNode rootResolutionNode, TypeCriteriaCollector collector)
125
var localResolveResult = ctx.Resolve(parameter) as LocalResolveResult;
126
if (localResolveResult == null)
128
var variable = localResolveResult.Variable;
129
var typeKind = variable.Type.Kind;
130
if (!(typeKind == TypeKind.Class ||
131
typeKind == TypeKind.Struct ||
132
typeKind == TypeKind.Interface ||
133
typeKind == TypeKind.Array) ||
134
parameter.Type is PrimitiveType ||
135
!collector.UsedVariables.Contains(variable)) {
139
var candidateTypes = localResolveResult.Type.GetAllBaseTypes().ToList();
140
TypesChecked += candidateTypes.Count;
141
var criterion = collector.GetCriterion(variable);
144
(from type in candidateTypes
145
where !type.Equals(localResolveResult.Type) && criterion.SatisfiedBy(type)
146
select type).ToList();
148
TypeResolveCount += possibleTypes.Count;
150
(from type in possibleTypes
151
where !tryResolve || TypeChangeResolvesCorrectly(ctx, parameter, rootResolutionNode, type)
152
select type).ToList();
153
if (validTypes.Any()) {
154
// don't demote an array to IList
155
if (variable.Type.Kind == TypeKind.Array && validTypes.Any (t => t.Namespace == "System.Collections" && t.Name == "IList")) {
158
AddIssue(parameter, ctx.TranslateString("Parameter can be demoted to base class"), GetActions(parameter, validTypes));
163
internal int TypeResolveCount = 0;
164
internal int TypesChecked = 0;
165
internal int MembersWithIssues = 0;
166
internal int MethodResolveCount = 0;
168
IEnumerable<CodeAction> GetActions(ParameterDeclaration parameter, IEnumerable<IType> possibleTypes)
170
var csResolver = ctx.Resolver.GetResolverStateBefore(parameter);
171
var astBuilder = new TypeSystemAstBuilder(csResolver);
172
foreach (var type in possibleTypes) {
173
var localType = type;
174
var message = String.Format(ctx.TranslateString("Demote parameter to '{0}'"), type.FullName);
175
yield return new CodeAction(message, script => {
176
script.Replace(parameter.Type, astBuilder.ConvertType(localType));
177
}, parameter.NameToken);
182
public static bool TypeChangeResolvesCorrectly(BaseRefactoringContext ctx, ParameterDeclaration parameter, AstNode rootNode, IType type)
184
var resolver = ctx.GetResolverStateBefore(rootNode);
185
resolver = resolver.AddVariable(new DefaultParameter(type, parameter.Name));
186
var astResolver = new CSharpAstResolver(resolver, rootNode, ctx.UnresolvedFile);
187
var validator = new TypeChangeValidationNavigator();
188
astResolver.ApplyNavigator(validator, ctx.CancellationToken);
189
return !validator.FoundErrors;
192
class TypeChangeValidationNavigator : IResolveVisitorNavigator
194
public bool FoundErrors { get; private set; }
196
#region IResolveVisitorNavigator implementation
197
public ResolveVisitorNavigationMode Scan(AstNode node)
200
return ResolveVisitorNavigationMode.Skip;
201
return ResolveVisitorNavigationMode.Resolve;
204
public void Resolved(AstNode node, ResolveResult result)
206
// bool errors = result.IsError;
207
FoundErrors |= result.IsError;
210
public void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType)