private List <MethodArgument> GetIndexerArguments(BracketedParameterListSyntax node)
{
var items = new List <MethodArgument>();
var parameters = node.ChildNodes().OfType <ParameterSyntax>();
foreach (var parameter in parameters)
{
var isIn = parameter.ChildTokens().Any(x => x.Kind() == SyntaxKind.InKeyword);
var isOut = parameter.ChildTokens().Any(x => x.Kind() == SyntaxKind.OutKeyword);
var isByRef = parameter.ChildTokens().Any(x => x.Kind() == SyntaxKind.RefKeyword);
var isByVal = !isByRef;
var isOptional = parameter.ChildNodes().Any(x => x is EqualsValueClauseSyntax);
var isParamArray = parameter.ChildTokens().Any(x => x.Kind() == SyntaxKind.ParamsKeyword);
var parameterName = parameter.ChildTokens().FirstOrDefault(x => x.Kind() == SyntaxKind.IdentifierToken).ToString();
var parameterType = parameter.ChildNodes().FirstOrDefault().ToString();
items.Add(new MethodArgument
{
IsByVal = isByVal,
IsByRef = isByRef,
IsIn = isIn,
IsOut = isOut,
IsOptional = isOptional,
IsParamArray = isParamArray,
DefineName = parameterName,
DefineType = RemoveNamespace(parameterType),
});
}
return(items);
}
public static BracketedParameterListSyntax WrapParameters(BracketedParameterListSyntax parameterList, CancellationToken cancellationToken = default)
{
SyntaxTriviaList leadingTrivia = GetIncreasedIndentationTriviaList(parameterList, cancellationToken);
var nodesAndTokens = new List <SyntaxNodeOrToken>();
SeparatedSyntaxList <ParameterSyntax> .Enumerator en = parameterList.Parameters.GetEnumerator();
SyntaxTrivia endOfLine = DetermineEndOfLine(parameterList);
if (en.MoveNext())
{
nodesAndTokens.Add(en.Current.WithLeadingTrivia(leadingTrivia));
while (en.MoveNext())
{
nodesAndTokens.Add(CommaToken().WithTrailingTrivia(endOfLine));
nodesAndTokens.Add(en.Current.WithLeadingTrivia(leadingTrivia));
}
}
return(BracketedParameterList(
OpenParenToken().WithTrailingTrivia(endOfLine),
SeparatedList <ParameterSyntax>(nodesAndTokens),
parameterList.CloseBracketToken));
}
//public override void VisitBaseExpression(BaseExpressionSyntax node)
//{
// base.VisitBaseExpression(node);
//}
//public override void VisitBaseList(BaseListSyntax node)
//{
// base.VisitBaseList(node);
//}
//public override void VisitBinaryExpression(BinaryExpressionSyntax node)
//{
// base.VisitBinaryExpression(node);
//}
//public override void VisitBlock(BlockSyntax node)
//{
// base.VisitBlock(node);
//}
//public override void VisitBracketedArgumentList(BracketedArgumentListSyntax node)
//{
// base.VisitBracketedArgumentList(node);
//}
public override void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
if (IsAnyNodeConst)
{
base.VisitBracketedParameterList(node);
}
}
private static void HandleIndexerDeclaration(SyntaxNodeAnalysisContext context)
{
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
BracketedParameterListSyntax argumentListSyntax = indexerDeclaration.ParameterList;
SeparatedSyntaxList <ParameterSyntax> arguments = argumentListSyntax.Parameters;
Analyze(context, arguments);
}
public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node)
{
BracketedParameterListSyntax parameterList = node.ParameterList;
parameterList = parameterList.WithCloseBracketToken(parameterList.CloseBracketToken.WithTrailingTrivia(Space));
return(base.VisitIndexerDeclaration(node.WithParameterList(parameterList).WithAccessorList(node.AccessorList.RemoveLineFeed())));
}
public static Doc Print(BracketedParameterListSyntax node)
{
return(Doc.Concat(
Token.Print(node.OpenBracketToken),
SeparatedSyntaxList.Print(node.Parameters, Parameter.Print, " "),
Token.Print(node.CloseBracketToken)
));
}
public static Task <Document> WrapParametersAsync(
Document document,
BracketedParameterListSyntax parameterList,
CancellationToken cancellationToken = default)
{
BracketedParameterListSyntax newNode = WrapParameters(parameterList);
return(document.ReplaceNodeAsync(parameterList, newNode, cancellationToken));
}
public override void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
foreach (ParameterSyntax parameter in node.Parameters)
{
parameter.Accept(this);
}
base.VisitBracketedParameterList(node);
}
public static string MapParameters(BracketedParameterListSyntax parameters, bool useLongNames = false, bool prettyPrint = true)
{
if (parameters == null)
{
return(string.Empty);
}
var paramList = (from ParameterSyntax parameter in parameters.Parameters select TypeMapper.Map(parameter.Type, useLongNames)).ToList();
return(prettyPrint ? $"[{string.Join(", ", paramList)}]" : string.Join(string.Empty, paramList));
}
public override Evaluation VisitBracketedParameterList(BracketedParameterListSyntax node)
{
EvaluationList list = new EvaluationList();
foreach (ParameterSyntax parameter in node.Parameters)
{
list.Add(parameter.Accept <Evaluation>(this));
}
return(list);
}
private void AnalyzeIndexerDeclaration(SyntaxNodeAnalysisContext context)
{
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
BracketedParameterListSyntax parameterList = indexerDeclaration.ParameterList;
if (parameterList != null)
{
Analyze(context, indexerDeclaration, parameterList.Parameters);
}
}
private static void HandleIndexerDeclaration(SyntaxNodeAnalysisContext context)
{
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
BracketedParameterListSyntax argumentListSyntax = indexerDeclaration.ParameterList;
SeparatedSyntaxList <ParameterSyntax> arguments = argumentListSyntax.Parameters;
if (arguments.Count > 1)
{
Analyze(context, argumentListSyntax.OpenBracketToken, arguments[0], arguments[1]);
}
}
public new void AddChildren()
{
base.AddChildren();
Kind = Node.Kind();
_thisKeyword = ((IndexerDeclarationSyntax)Node).ThisKeyword;
_thisKeywordIsChanged = false;
_parameterList = ((IndexerDeclarationSyntax)Node).ParameterList;
_parameterListIsChanged = false;
_expressionBody = ((IndexerDeclarationSyntax)Node).ExpressionBody;
_expressionBodyIsChanged = false;
_semicolonToken = ((IndexerDeclarationSyntax)Node).SemicolonToken;
_semicolonTokenIsChanged = false;
}
private Doc PrintBracketedParameterListSyntax(
BracketedParameterListSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.OpenBracketToken),
this.PrintSeparatedSyntaxList(
node.Parameters,
this.PrintParameterSyntax,
" "
),
this.PrintSyntaxToken(node.CloseBracketToken)
));
}
public static Task <Document> FixListAsync(
Document document,
BracketedParameterListSyntax bracketedParameterList,
ListFixMode fixMode = ListFixMode.Fix,
CancellationToken cancellationToken = default)
{
return(FixListAsync(
document,
bracketedParameterList,
bracketedParameterList.OpenBracketToken,
bracketedParameterList.Parameters,
fixMode,
cancellationToken));
}
public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
{
VisitAttributeLists(node.AttributeLists);
if (!ShouldVisit)
{
return;
}
TypeSyntax type = node.Type;
if (type != null)
{
VisitType(type);
}
if (!ShouldVisit)
{
return;
}
BracketedParameterListSyntax parameterList = node.ParameterList;
if (node != null)
{
VisitBracketedParameterList(parameterList);
}
if (!ShouldVisit)
{
return;
}
AccessorListSyntax accessorList = node.AccessorList;
if (accessorList != null)
{
VisitAccessorList(accessorList);
}
else
{
ArrowExpressionClauseSyntax expressionBody = node.ExpressionBody;
if (expressionBody != null)
{
VisitArrowExpressionClause(expressionBody);
}
}
}
public override void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (ParameterSyntax parameter in node.Parameters)
{
parameter.Accept(this);
}
base.VisitBracketedParameterList(node);
PostVisit(node);
}
public static IndexerDeclarationSyntax IndexerDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList)
{
return SyntaxFactory.IndexerDeclaration(
attributeLists: attributeLists,
modifiers: modifiers,
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
parameterList: parameterList,
accessorList: accessorList,
expressionBody: default(ArrowExpressionClauseSyntax));
}
public static IndexerDeclarationSyntax IndexerDeclaration(
SyntaxList <AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList)
{
return(SyntaxFactory.IndexerDeclaration(
attributeLists: attributeLists,
modifiers: modifiers,
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
parameterList: parameterList,
accessorList: accessorList,
expressionBody: default(ArrowExpressionClauseSyntax)));
}
public static IndexerDeclarationSyntax Update(
this IndexerDeclarationSyntax syntax,
SyntaxList <AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken thisKeyword,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList)
{
return(syntax.Update(
attributeLists,
modifiers,
type,
explicitInterfaceSpecifier,
thisKeyword,
parameterList,
accessorList,
expressionBody: default,
public static IndexerDeclarationSyntax Update(
this IndexerDeclarationSyntax syntax,
SyntaxList <AttributeSyntax> attributeLists,
SyntaxTokenList modifiers,
SyntaxToken funcKeyword,
SyntaxToken operatorKeyword,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken minusGreaterThanOrEqualToken,
TypeSyntax type,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList)
{
return(syntax.Update(
attributeLists,
modifiers,
funcKeyword,
operatorKeyword,
explicitInterfaceSpecifier,
parameterList,
minusGreaterThanOrEqualToken,
type,
public static IndexerDeclarationSyntax IndexerDeclaration(
SyntaxList <AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken thisKeyword,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList,
ArrowExpressionClauseSyntax expressionBody,
SyntaxToken semicolonToken)
{
return(SyntaxFactory.IndexerDeclaration(
attributeLists: attributeLists,
modifiers: modifiers,
refKeyword: default(SyntaxToken),
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
thisKeyword: thisKeyword,
parameterList: parameterList,
accessorList: accessorList,
expressionBody: expressionBody,
semicolonToken: semicolonToken));
}
public static IndexerDeclarationSyntax IndexerDeclaration(
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken thisKeyword,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList,
ArrowExpressionClauseSyntax expressionBody,
SyntaxToken semicolonToken)
{
return SyntaxFactory.IndexerDeclaration(
attributeLists: attributeLists,
modifiers: modifiers,
refKeyword: default(SyntaxToken),
type: type,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
thisKeyword: thisKeyword,
parameterList: parameterList,
accessorList: accessorList,
expressionBody: expressionBody,
semicolonToken: semicolonToken);
}
private static void AnalyzeBracketParametersList(SyntaxNodeAnalysisContext context, BracketedParameterListSyntax parameterListSyntax)
{
var openBracketToken = parameterListSyntax.OpenBracketToken;
if (openBracketToken.IsMissing ||
parameterListSyntax.IsMissing ||
!parameterListSyntax.Parameters.Any())
{
return;
}
var firstParameter = parameterListSyntax.Parameters[0];
var firstParameterLineSpan = firstParameter.GetLocation().GetLineSpan();
if (!firstParameterLineSpan.IsValid)
{
return;
}
var openBracketLineSpan = openBracketToken.GetLocation().GetLineSpan();
if (!openBracketLineSpan.IsValid)
{
return;
}
if (openBracketLineSpan.EndLinePosition.Line != firstParameterLineSpan.StartLinePosition.Line &&
openBracketLineSpan.EndLinePosition.Line != (firstParameterLineSpan.StartLinePosition.Line - 1))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstParameter.GetLocation()));
}
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitBracketedParameterList(node);
}
public override UstNode VisitBracketedParameterList(BracketedParameterListSyntax node)
{
return(base.VisitBracketedParameterList(node));
}
public void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
_writer.WriteSyntax(Syntax.OpenBracket);
bool hadOne = false;
foreach (var parameter in node.Parameters)
{
if (hadOne)
_writer.WriteListSeparator();
else
hadOne = true;
parameter.Accept(this);
}
_writer.WriteSyntax(Syntax.CloseBracket);
}
public TameBracketedParameterListSyntax(BracketedParameterListSyntax node)
{
Node = node;
AddChildren();
}
public static void Analyze(SyntaxNodeAnalysisContext context, AccessorListSyntax accessorList)
{
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Any(f => f.BodyOrExpressionBody() != null))
{
if (accessorList.IsSingleLine(includeExteriorTrivia: false))
{
ReportDiagnostic(context, accessorList);
}
else
{
foreach (AccessorDeclarationSyntax accessor in accessors)
{
if (ShouldBeFormatted(accessor))
{
ReportDiagnostic(context, accessor);
}
}
}
}
else
{
SyntaxNode parent = accessorList.Parent;
switch (parent?.Kind())
{
case SyntaxKind.PropertyDeclaration:
{
if (accessors.All(f => !f.AttributeLists.Any()) &&
!accessorList.IsSingleLine(includeExteriorTrivia: false))
{
var propertyDeclaration = (PropertyDeclarationSyntax)parent;
SyntaxToken identifier = propertyDeclaration.Identifier;
if (!identifier.IsMissing)
{
SyntaxToken closeBrace = accessorList.CloseBraceToken;
if (!closeBrace.IsMissing)
{
TextSpan span = TextSpan.FromBounds(identifier.Span.End, closeBrace.Span.Start);
if (propertyDeclaration
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, accessorList);
}
}
}
}
break;
}
case SyntaxKind.IndexerDeclaration:
{
if (accessors.All(f => !f.AttributeLists.Any()) &&
!accessorList.IsSingleLine(includeExteriorTrivia: false))
{
var indexerDeclaration = (IndexerDeclarationSyntax)parent;
BracketedParameterListSyntax parameterList = indexerDeclaration.ParameterList;
if (parameterList != null)
{
SyntaxToken closeBracket = parameterList.CloseBracketToken;
if (!closeBracket.IsMissing)
{
SyntaxToken closeBrace = accessorList.CloseBraceToken;
if (!closeBrace.IsMissing)
{
TextSpan span = TextSpan.FromBounds(closeBracket.Span.End, closeBrace.Span.Start);
if (indexerDeclaration
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
ReportDiagnostic(context, accessorList);
}
}
}
}
}
break;
}
}
}
}
public IndexerDeclarationSyntax Update(SyntaxList<AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken thisKeyword, BracketedParameterListSyntax parameterList, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
{
return Update(attributeLists, modifiers, this.RefKeyword, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitBracketedParameterList(node);
}
public override void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
throw new NotImplementedException();
}
public IndexerDeclarationSyntax Update(SyntaxList <AttributeListSyntax> attributeLists, SyntaxTokenList modifiers, TypeSyntax type, ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier, SyntaxToken thisKeyword, BracketedParameterListSyntax parameterList, AccessorListSyntax accessorList, ArrowExpressionClauseSyntax expressionBody, SyntaxToken semicolonToken)
{
return(Update(attributeLists, modifiers, this.RefKeyword, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken));
}
public static IndexerDeclarationSyntax Update(
this IndexerDeclarationSyntax syntax,
SyntaxList<AttributeListSyntax> attributeLists,
SyntaxTokenList modifiers,
TypeSyntax type,
ExplicitInterfaceSpecifierSyntax explicitInterfaceSpecifier,
SyntaxToken thisKeyword,
BracketedParameterListSyntax parameterList,
AccessorListSyntax accessorList)
{
return syntax.Update(
attributeLists,
modifiers,
default(SyntaxToken),
type,
explicitInterfaceSpecifier,
thisKeyword,
parameterList,
accessorList,
default(ArrowExpressionClauseSyntax),
default(SyntaxToken));
}
private static void AnalyzeBracketParametersList(SyntaxNodeAnalysisContext context, BracketedParameterListSyntax parameterListSyntax)
{
var openBracketToken = parameterListSyntax.OpenBracketToken;
if (openBracketToken.IsMissing ||
parameterListSyntax.IsMissing ||
!parameterListSyntax.Parameters.Any())
{
return;
}
var firstParameter = parameterListSyntax.Parameters[0];
var firstParameterLineSpan = firstParameter.GetLineSpan();
if (!firstParameterLineSpan.IsValid)
{
return;
}
var openBracketLineSpan = openBracketToken.GetLineSpan();
if (!openBracketLineSpan.IsValid)
{
return;
}
if (openBracketLineSpan.EndLinePosition.Line != firstParameterLineSpan.StartLinePosition.Line &&
openBracketLineSpan.EndLinePosition.Line != (firstParameterLineSpan.StartLinePosition.Line - 1))
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, firstParameter.GetLocation()));
}
}
private static void AnalyzeAccessorList(SyntaxNodeAnalysisContext context)
{
var accessorList = (AccessorListSyntax)context.Node;
SyntaxList <AccessorDeclarationSyntax> accessors = accessorList.Accessors;
if (accessors.Any(f => f.BodyOrExpressionBody() != null))
{
if (DiagnosticDescriptors.AddNewLineBeforeAccessorOfFullProperty.IsEffective(context))
{
SyntaxToken token = accessorList.OpenBraceToken;
foreach (AccessorDeclarationSyntax accessor in accessors)
{
if (accessor.BodyOrExpressionBody() != null &&
accessor.SyntaxTree.IsSingleLineSpan(TextSpan.FromBounds(token.Span.End, accessor.SpanStart)))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.AddNewLineBeforeAccessorOfFullProperty,
Location.Create(accessor.SyntaxTree, new TextSpan(accessor.SpanStart, 0)));
break;
}
token = accessor.Body?.CloseBraceToken ?? accessor.SemicolonToken;
if (!token.Equals(accessor.GetLastToken()))
{
break;
}
}
}
if (DiagnosticDescriptors.RemoveNewLinesFromAccessorWithSingleLineExpression.IsEffective(context) &&
!accessorList.IsSingleLine(includeExteriorTrivia: false))
{
foreach (AccessorDeclarationSyntax accessor in accessors)
{
if (CanRemoveNewLinesFromAccessor(accessor))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveNewLinesFromAccessorWithSingleLineExpression, accessor);
}
}
}
}
else if (DiagnosticDescriptors.RemoveNewLinesFromAccessorListOfAutoProperty.IsEffective(context))
{
SyntaxNode parent = accessorList.Parent;
switch (parent?.Kind())
{
case SyntaxKind.PropertyDeclaration:
{
if (accessors.All(f => !f.AttributeLists.Any()) &&
!accessorList.IsSingleLine(includeExteriorTrivia: false))
{
var propertyDeclaration = (PropertyDeclarationSyntax)parent;
SyntaxToken identifier = propertyDeclaration.Identifier;
if (!identifier.IsMissing)
{
SyntaxToken closeBrace = accessorList.CloseBraceToken;
if (!closeBrace.IsMissing)
{
TextSpan span = TextSpan.FromBounds(identifier.Span.End, closeBrace.SpanStart);
if (propertyDeclaration
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveNewLinesFromAccessorListOfAutoProperty, accessorList);
}
}
}
}
break;
}
case SyntaxKind.IndexerDeclaration:
{
if (accessors.All(f => !f.AttributeLists.Any()) &&
!accessorList.IsSingleLine(includeExteriorTrivia: false))
{
var indexerDeclaration = (IndexerDeclarationSyntax)parent;
BracketedParameterListSyntax parameterList = indexerDeclaration.ParameterList;
if (parameterList != null)
{
SyntaxToken closeBracket = parameterList.CloseBracketToken;
if (!closeBracket.IsMissing)
{
SyntaxToken closeBrace = accessorList.CloseBraceToken;
if (!closeBrace.IsMissing)
{
TextSpan span = TextSpan.FromBounds(closeBracket.Span.End, closeBrace.SpanStart);
if (indexerDeclaration
.DescendantTrivia(span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveNewLinesFromAccessorListOfAutoProperty, accessorList);
}
}
}
}
}
break;
}
}
}
}
public BracketedParameterListTranslation(BracketedParameterListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
}
public override void VisitBracketedParameterList(BracketedParameterListSyntax node)
{
}
public static List <ParameterInfo> Parse(BracketedParameterListSyntax syntax) => syntax?.Parameters.Select(p => new ParameterInfo(p)).ToList() ?? new List <ParameterInfo>();
