private static void AnalyzeParameterList(SyntaxNodeAnalysisContext context, BaseParameterListSyntax parameterListSyntax)
{
if (parameterListSyntax == null
|| parameterListSyntax.Parameters.Count < 2)
{
return;
}
var previousLine = parameterListSyntax.Parameters[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < parameterListSyntax.Parameters.Count; i++)
{
var currentParameter = parameterListSyntax.Parameters[i];
var lineSpan = currentParameter.GetLineSpan();
var currentLine = lineSpan.StartLinePosition.Line;
if (currentLine - previousLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentParameter.GetLocation()));
}
previousLine = lineSpan.EndLinePosition.Line;
}
}
private static ImmutableArray<ParameterSymbol> MakeParameters(Binder binder, SourcePropertySymbol owner, BaseParameterListSyntax parameterSyntaxOpt, DiagnosticBag diagnostics)
{
if (parameterSyntaxOpt == null)
{
return ImmutableArray<ParameterSymbol>.Empty;
}
SyntaxToken arglistToken;
var parameters = ParameterHelpers.MakeParameters(binder, owner, parameterSyntaxOpt, false, out arglistToken, diagnostics, false);
if (arglistToken.Kind() != SyntaxKind.None)
{
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, arglistToken.GetLocation());
}
// There is a special warning for an indexer with exactly one parameter, which is optional.
// ParameterHelpers already warns for default values on explicit interface implementations.
if (parameters.Length == 1 && !owner.IsExplicitInterfaceImplementation)
{
ParameterSyntax parameterSyntax = parameterSyntaxOpt.Parameters[0];
if (parameterSyntax.Default != null)
{
SyntaxToken paramNameToken = parameterSyntax.Identifier;
diagnostics.Add(ErrorCode.WRN_DefaultValueForUnconsumedLocation, paramNameToken.GetLocation(), paramNameToken.ValueText);
}
}
return parameters;
}
private static void AnalyzeParameterList(SyntaxNodeAnalysisContext context, BaseParameterListSyntax parameterListSyntax)
{
if (parameterListSyntax == null
|| parameterListSyntax.Parameters.Count < 2)
{
return;
}
var previousParameterLine = parameterListSyntax.Parameters[0].GetLineSpan().EndLinePosition.Line;
for (int i = 1; i < parameterListSyntax.Parameters.Count; i++)
{
var currentParameter = parameterListSyntax.Parameters[i];
int currentParameterLine;
if (currentParameter.HasLeadingTrivia && IsValidTrivia(currentParameter.GetLeadingTrivia()))
{
currentParameterLine = currentParameter.SyntaxTree.GetLineSpan(currentParameter.FullSpan).StartLinePosition.Line;
}
else
{
currentParameterLine = currentParameter.GetLineSpan().StartLinePosition.Line;
}
if (currentParameterLine - previousParameterLine > 1)
{
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentParameter.GetLocation()));
}
previousParameterLine = currentParameterLine;
}
}
public BaseParameterListTranslation(BaseParameterListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Parameters = syntax.Parameters.Get<ParameterSyntax, ParameterTranslation>(this);
}
private static void AppendParameterList(StringBuilder builder, BaseParameterListSyntax parameterList)
{
builder.Append(parameterList is BracketedParameterListSyntax ? '[' : '(');
var firstSeen = false;
foreach (var parameter in parameterList.Parameters)
{
if (firstSeen)
{
builder.Append(",");
}
if (parameter.Modifiers.Any(SyntaxKind.RefKeyword))
{
builder.Append("ref ");
}
else if (parameter.Modifiers.Any(SyntaxKind.OutKeyword))
{
builder.Append("out ");
}
else if (parameter.Modifiers.Any(SyntaxKind.ParamsKeyword))
{
builder.Append("params ");
}
AppendTypeName(builder, parameter.Type);
firstSeen = true;
}
builder.Append(parameterList is BracketedParameterListSyntax ? ']' : ')');
}
private void AddParameters(BaseParameterListSyntax parameterList)
{
if (parameterList != null)
{
_expressions.AddRange(
from p in parameterList.Parameters
select p.Identifier.ValueText);
}
}
public static ImmutableArray <ParameterSymbol> MakeParameters(
Binder binder,
Symbol owner,
BaseParameterListSyntax syntax,
out SyntaxToken arglistToken,
DiagnosticBag diagnostics,
bool allowRefOrOut,
bool allowThis)
{
arglistToken = default(SyntaxToken);
int parameterIndex = 0;
int firstDefault = -1;
var builder = ArrayBuilder <ParameterSymbol> .GetInstance();
ImmutableArray <ParameterSymbol> parameters;
foreach (var parameterSyntax in syntax.Parameters)
{
CheckParameterModifiers(parameterSyntax, diagnostics);
var refKind = GetModifiers(parameterSyntax.Modifiers,
out SyntaxToken outKeyword, out SyntaxToken refKeyword,
out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword);
if (thisKeyword.Kind() != SyntaxKind.None && !allowThis)
{
diagnostics.Add(ErrorCode.ERR_ThisInBadContext, thisKeyword.GetLocation());
}
if (parameterSyntax.IsArgList)
{
arglistToken = parameterSyntax.Identifier;
// The native compiler produces "Expected type" here, in the parser. Roslyn produces
// the somewhat more informative "arglist not valid" error.
if (paramsKeyword.Kind() != SyntaxKind.None || outKeyword.Kind() != SyntaxKind.None ||
refKeyword.Kind() != SyntaxKind.None || thisKeyword.Kind() != SyntaxKind.None)
{
// CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, arglistToken.GetLocation());
}
continue;
}
if (parameterSyntax.Default != null && firstDefault == -1)
{
firstDefault = parameterIndex;
}
Debug.Assert(parameterSyntax.Type != null);
var parameterType = binder.BindType(parameterSyntax.Type, diagnostics);
if (!allowRefOrOut && (refKind != RefKind.None))
{
var outOrRefKeyword = (outKeyword.Kind() != SyntaxKind.None) ? outKeyword : refKeyword;
Debug.Assert(outOrRefKeyword.Kind() != SyntaxKind.None);
// error CS0631: ref and out are not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalRefParam, outOrRefKeyword.GetLocation());
}
var parameter = SourceParameterSymbol.Create(
binder,
owner,
parameterType,
parameterSyntax,
refKind,
parameterSyntax.Identifier,
parameterIndex,
(paramsKeyword.Kind() != SyntaxKind.None),
parameterIndex == 0 && thisKeyword.Kind() != SyntaxKind.None,
diagnostics);
ReportParameterErrors(owner, parameterSyntax, parameter, firstDefault, diagnostics);
builder.Add(parameter);
++parameterIndex;
}
parameters = builder.ToImmutableAndFree();
var methodOwner = owner as MethodSymbol;
var typeParameters = (object)methodOwner != null ?
methodOwner.TypeParameters :
default(ImmutableArray <TypeParameterSymbol>);
binder.ValidateParameterNameConflicts(typeParameters, parameters, diagnostics);
return(parameters);
}
private static IEnumerable <SyntaxNode> GetParameterListInitializersAndAttributes(BaseParameterListSyntax parameterList) =>
parameterList != null?
parameterList.Parameters.SelectMany(p => GetParameterInitializersAndAttributes(p)) :
SpecializedCollections.EmptyEnumerable <SyntaxNode>();
public static ImmutableArray <ParameterSymbol> MakeParameters(
Binder binder,
Symbol owner,
BaseParameterListSyntax syntax,
out SyntaxToken arglistToken,
DiagnosticBag diagnostics,
bool allowRefOrOut,
bool allowThis,
bool addRefReadOnlyModifier)
{
arglistToken = default(SyntaxToken);
int parameterIndex = 0;
int firstDefault = -1;
var builder = ArrayBuilder <ParameterSymbol> .GetInstance();
var mustBeLastParameter = (ParameterSyntax)null;
foreach (var parameterSyntax in syntax.Parameters)
{
var extendedParameterType = parameterSyntax.Type as ExtendedTypeSyntax;
if (mustBeLastParameter == null)
{
if (extendedParameterType != null && extendedParameterType.Modifiers.Any(SyntaxKind.ParamsKeyword) ||
parameterSyntax.Identifier.Kind() == SyntaxKind.ArgListKeyword)
{
mustBeLastParameter = parameterSyntax;
}
}
CheckParameterModifiers(parameterSyntax, diagnostics);
RefKind refKind = parameterSyntax.Type.GetRefKind();
SyntaxToken refnessKeyword = default;
GetModifiers(extendedParameterType?.Modifiers, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword);
if (thisKeyword.Kind() != SyntaxKind.None && !allowThis)
{
diagnostics.Add(ErrorCode.ERR_ThisInBadContext, thisKeyword.GetLocation());
}
if (parameterSyntax.IsArgList)
{
arglistToken = parameterSyntax.Identifier;
// The native compiler produces "Expected type" here, in the parser. Roslyn produces
// the somewhat more informative "arglist not valid" error.
if (paramsKeyword.Kind() != SyntaxKind.None ||
refnessKeyword.Kind() != SyntaxKind.None ||
thisKeyword.Kind() != SyntaxKind.None)
{
// CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, arglistToken.GetLocation());
}
continue;
}
if (parameterSyntax.Default != null && firstDefault == -1)
{
firstDefault = parameterIndex;
}
Debug.Assert(parameterSyntax.Type != null);
var parameterType = binder.BindType(parameterSyntax.Type, diagnostics);
if (!allowRefOrOut && (refKind == RefKind.Ref || refKind == RefKind.Out))
{
Debug.Assert(refnessKeyword.Kind() != SyntaxKind.None);
// error CS0631: ref and out are not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalRefParam, refnessKeyword.GetLocation());
}
var parameter = SourceParameterSymbol.Create(
binder,
owner,
parameterType,
parameterSyntax,
refKind,
parameterSyntax.Identifier,
parameterIndex,
(paramsKeyword.Kind() != SyntaxKind.None),
parameterIndex == 0 && thisKeyword.Kind() != SyntaxKind.None,
addRefReadOnlyModifier,
diagnostics);
ReportParameterErrors(owner, parameterSyntax, parameter, thisKeyword, paramsKeyword, firstDefault, diagnostics);
builder.Add(parameter);
++parameterIndex;
}
if (mustBeLastParameter != null && mustBeLastParameter != syntax.Parameters.Last())
{
diagnostics.Add(
mustBeLastParameter.Identifier.Kind() == SyntaxKind.ArgListKeyword
? ErrorCode.ERR_VarargsLast
: ErrorCode.ERR_ParamsLast,
mustBeLastParameter.GetLocation());
}
ImmutableArray <ParameterSymbol> parameters = builder.ToImmutableAndFree();
var methodOwner = owner as MethodSymbol;
var typeParameters = (object)methodOwner != null ?
methodOwner.TypeParameters :
default(ImmutableArray <TypeParameterSymbol>);
Debug.Assert(methodOwner?.MethodKind != MethodKind.LambdaMethod);
bool allowShadowingNames = binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureNameShadowingInNestedFunctions) &&
methodOwner?.MethodKind == MethodKind.LocalFunction;
binder.ValidateParameterNameConflicts(typeParameters, parameters, allowShadowingNames, diagnostics);
return(parameters);
}
private static void HandleBaseParameterListSyntax(SyntaxNodeAnalysisContext context, BaseParameterListSyntax parameterList)
{
if (parameterList != null && !parameterList.IsMissing)
{
var parameters = parameterList.Parameters;
if (parameters.Count > 1)
{
CheckIfCommasAreAtTheSameLineAsThePreviousParameter(context, parameters.GetWithSeparators());
}
}
}
public ParameterInfo(BaseParameterListSyntax parameterList, CSharpSyntaxNode body)
: this(parameterList, default(TypeParameterListSyntax), body)
{
}
public TameBaseParameterListSyntax(BaseParameterListSyntax node)
{
Node = node;
AddChildren();
}
// 形参表基类
public virtual void VisitBaseParameterListSyntax(BaseParameterListSyntax value)
{
DefaultVisit(value);
}
private static void HandleBaseParameterListSyntax(SyntaxNodeAnalysisContext context, BaseParameterListSyntax parameterList)
{
if (parameterList != null && !parameterList.IsMissing)
{
var parameters = parameterList.Parameters;
if (parameters.Count > 1)
{
CheckIfCommasAreAtTheSameLineAsThePreviousParameter(context, parameters.GetWithSeparators());
}
}
}
public static MemberDeclarationSyntax WithParameterList(
this MemberDeclarationSyntax member,
BaseParameterListSyntax parameterList)
{
if (member != null)
{
switch (member.Kind())
{
case SyntaxKind.DelegateDeclaration:
return ((DelegateDeclarationSyntax)member).WithParameterList((ParameterListSyntax)parameterList);
case SyntaxKind.MethodDeclaration:
return ((MethodDeclarationSyntax)member).WithParameterList((ParameterListSyntax)parameterList);
case SyntaxKind.ConstructorDeclaration:
return ((ConstructorDeclarationSyntax)member).WithParameterList((ParameterListSyntax)parameterList);
case SyntaxKind.IndexerDeclaration:
return ((IndexerDeclarationSyntax)member).WithParameterList((BracketedParameterListSyntax)parameterList);
case SyntaxKind.OperatorDeclaration:
return ((OperatorDeclarationSyntax)member).WithParameterList((ParameterListSyntax)parameterList);
case SyntaxKind.ConversionOperatorDeclaration:
return ((ConversionOperatorDeclarationSyntax)member).WithParameterList((ParameterListSyntax)parameterList);
}
}
return null;
}
public static ImmutableArray<ParameterSymbol> MakeParameters(
Binder binder,
Symbol owner,
BaseParameterListSyntax syntax,
bool allowRefOrOut,
out SyntaxToken arglistToken,
DiagnosticBag diagnostics)
{
arglistToken = default(SyntaxToken);
int parameterIndex = 0;
int firstDefault = -1;
var builder = ArrayBuilder<ParameterSymbol>.GetInstance();
ImmutableArray<ParameterSymbol> parameters;
foreach (var parameterSyntax in syntax.Parameters)
{
SyntaxToken outKeyword;
SyntaxToken refKeyword;
SyntaxToken paramsKeyword;
SyntaxToken thisKeyword;
var refKind = GetModifiers(parameterSyntax.Modifiers, out outKeyword, out refKeyword, out paramsKeyword, out thisKeyword);
if (parameterSyntax.IsArgList)
{
arglistToken = parameterSyntax.Identifier;
// The native compiler produces "Expected type" here, in the parser. Roslyn produces
// the somewhat more informative "arglist not valid" error.
if (paramsKeyword.Kind() != SyntaxKind.None || outKeyword.Kind() != SyntaxKind.None ||
refKeyword.Kind() != SyntaxKind.None || thisKeyword.Kind() != SyntaxKind.None)
{
// CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, arglistToken.GetLocation());
}
continue;
}
if (parameterSyntax.Default != null && firstDefault == -1)
{
firstDefault = parameterIndex;
}
Debug.Assert(parameterSyntax.Type != null);
var parameterType = binder.BindType(parameterSyntax.Type, diagnostics);
if (!allowRefOrOut && (refKind != RefKind.None))
{
var outOrRefKeyword = (outKeyword.Kind() != SyntaxKind.None) ? outKeyword : refKeyword;
Debug.Assert(outOrRefKeyword.Kind() != SyntaxKind.None);
// error CS0631: ref and out are not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalRefParam, outOrRefKeyword.GetLocation());
}
var parameter = SourceParameterSymbol.Create(
binder,
owner,
parameterType,
parameterSyntax,
refKind,
parameterSyntax.Identifier,
parameterIndex,
(paramsKeyword.Kind() != SyntaxKind.None),
parameterIndex == 0 && thisKeyword.Kind() != SyntaxKind.None,
diagnostics);
ReportParameterErrors(owner, parameterSyntax, parameter, firstDefault, diagnostics);
builder.Add(parameter);
++parameterIndex;
}
parameters = builder.ToImmutableAndFree();
var methodOwner = owner as MethodSymbol;
var typeParameters = (object)methodOwner != null ?
methodOwner.TypeParameters :
default(ImmutableArray<TypeParameterSymbol>);
binder.ValidateParameterNameConflicts(typeParameters, parameters, diagnostics);
return parameters;
}
public BaseParameterListTranslation(BaseParameterListSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Parameters = syntax.Parameters.Get <ParameterSyntax, ParameterTranslation>(this);
}
