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); }
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); }