void ProcessParameter(ParameterDeclaration parameter, AstNode rootResolutionNode, TypeCriteriaCollector collector)
            {
                var localResolveResult = ctx.Resolve(parameter) as LocalResolveResult;

                if (localResolveResult == null)
                {
                    return;
                }
                var variable = localResolveResult.Variable;
                var typeKind = variable.Type.Kind;

                if (!(typeKind == TypeKind.Class ||
                      typeKind == TypeKind.Struct ||
                      typeKind == TypeKind.Interface ||
                      typeKind == TypeKind.Array) ||
                    parameter.Type is PrimitiveType ||
                    !collector.UsedVariables.Contains(variable))
                {
                    return;
                }

                var candidateTypes = localResolveResult.Type.GetAllBaseTypes().ToList();

                TypesChecked += candidateTypes.Count;
                var criterion = collector.GetCriterion(variable);

                var possibleTypes =
                    (from type in candidateTypes
                     where !type.Equals(localResolveResult.Type) && criterion.SatisfiedBy(type)
                     select type).ToList();

                TypeResolveCount += possibleTypes.Count;
                var validTypes =
                    (from type in possibleTypes
                     where !tryResolve || TypeChangeResolvesCorrectly(ctx, parameter, rootResolutionNode, type)
                     select type).ToList();

                if (validTypes.Any())
                {
                    // don't demote an array to IList
                    if (variable.Type.Kind == TypeKind.Array && validTypes.Any(t => t.Namespace == "System.Collections" && t.Name == "IList"))
                    {
                        return;
                    }
                    AddIssue(parameter, ctx.TranslateString("Parameter can be demoted to base class"), GetActions(parameter, validTypes));
                    MembersWithIssues++;
                }
            }
Beispiel #2
0
            void ProcessParameter(ParameterDeclaration parameter, AstNode rootResolutionNode, TypeCriteriaCollector collector)
            {
                var localResolveResult = ctx.Resolve(parameter) as LocalResolveResult;

                if (localResolveResult == null)
                {
                    return;
                }
                var variable = localResolveResult.Variable;
                var typeKind = variable.Type.Kind;

                if (!(typeKind == TypeKind.Class ||
                      typeKind == TypeKind.Struct ||
                      typeKind == TypeKind.Interface ||
                      typeKind == TypeKind.Array) ||
                    parameter.Type is PrimitiveType ||
                    !collector.UsedVariables.Contains(variable))
                {
                    return;
                }

                var candidateTypes = localResolveResult.Type.GetAllBaseTypes().ToList();

                TypesChecked += candidateTypes.Count;
                var criterion = collector.GetCriterion(variable);

                var possibleTypes =
                    (from type in candidateTypes
                     where !type.Equals(localResolveResult.Type) && criterion.SatisfiedBy(type)
                     select type).ToList();

                TypeResolveCount += possibleTypes.Count;
                var validTypes =
                    (from type in possibleTypes
                     where (!tryResolve || TypeChangeResolvesCorrectly(ctx, parameter, rootResolutionNode, type)) && !FilterOut(variable.Type, type)
                     select type).ToList();

                if (validTypes.Any())
                {
                    AddIssue(new CodeIssue(parameter.Type, ctx.TranslateString("Parameter can be declared with base type"), GetActions(parameter, validTypes))
                    {
                        IssueMarker = IssueMarker.DottedLine
                    });
                    MembersWithIssues++;
                }
            }
			void ProcessParameter(ParameterDeclaration parameter, AstNode rootResolutionNode, TypeCriteriaCollector collector)
			{
				var localResolveResult = ctx.Resolve(parameter) as LocalResolveResult;
				var variable = localResolveResult.Variable;
				var typeKind = variable.Type.Kind;
				if (!(typeKind == TypeKind.Class ||
					  typeKind == TypeKind.Struct ||
					  typeKind == TypeKind.Interface ||
					  typeKind == TypeKind.Array) ||
				    parameter.Type is PrimitiveType ||
					!collector.UsedVariables.Contains(variable)) {
					return;
				}

				var candidateTypes = localResolveResult.Type.GetAllBaseTypes().ToList();
				TypesChecked += candidateTypes.Count;
				var criterion = collector.GetCriterion(variable);

				var possibleTypes = 
					(from type in candidateTypes
					 where !type.Equals(localResolveResult.Type) && criterion.SatisfiedBy(type)
					 select type).ToList();

				TypeResolveCount += possibleTypes.Count;
				var validTypes = 
					(from type in possibleTypes
					 where !tryResolve || TypeChangeResolvesCorrectly(parameter, rootResolutionNode, type)
					 orderby GetInheritanceDepth(type) ascending
					 select type).ToList();
				if (validTypes.Any()) {
					AddIssue(parameter, ctx.TranslateString("Parameter can be demoted to base class"), GetActions(parameter, validTypes));
					MembersWithIssues++;
				}
			}