private void ReportDiagnosticsIfNeeded(NameEqualsSyntax nameEquals, SyntaxNodeAnalysisContext context, AnalyzerOptions options, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
if (!nameEquals.Parent.IsKind(SyntaxKind.AnonymousObjectMemberDeclarator, out AnonymousObjectMemberDeclaratorSyntax? anonCtor))
{
return;
}
var preference = options.GetOption(
CodeStyleOptions2.PreferInferredAnonymousTypeMemberNames, context.Compilation.Language, syntaxTree, cancellationToken);
if (!preference.Value ||
!CSharpInferredMemberNameSimplifier.CanSimplifyAnonymousTypeMemberName(anonCtor))
{
return;
}
// Create a normal diagnostic
var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);
context.ReportDiagnostic(
DiagnosticHelper.CreateWithLocationTags(
Descriptor,
nameEquals.GetLocation(),
preference.Notification.Severity,
additionalLocations: ImmutableArray <Location> .Empty,
additionalUnnecessaryLocations: ImmutableArray.Create(syntaxTree.GetLocation(fadeSpan))));
}
public static void ComputeRefactoring(RefactoringContext context, UsingDirectiveSyntax usingDirective)
{
if (context.IsRefactoringEnabled(RefactoringDescriptors.InlineAliasExpression))
{
NameEqualsSyntax alias = usingDirective.Alias;
if (alias != null)
{
IdentifierNameSyntax name = alias.Name;
if (name != null &&
context.Span.IsContainedInSpanOrBetweenSpans(name))
{
context.RegisterRefactoring(
"Inline alias expression",
ct => InlineAliasExpressionRefactoring.RefactorAsync(context.Document, usingDirective, ct),
RefactoringDescriptors.InlineAliasExpression);
}
}
}
if (context.IsRefactoringEnabled(RefactoringDescriptors.InlineUsingStaticDirective) &&
usingDirective.StaticKeyword.IsKind(SyntaxKind.StaticKeyword) &&
usingDirective.IsParentKind(SyntaxKind.CompilationUnit, SyntaxKind.NamespaceDeclaration))
{
context.RegisterRefactoring(
"Inline using static",
ct => InlineUsingStaticDirectiveRefactoring.RefactorAsync(context.Document, usingDirective, ct),
RefactoringDescriptors.InlineUsingStaticDirective);
}
}
private void ReportDiagnosticsIfNeeded(NameEqualsSyntax nameEquals, SyntaxNodeAnalysisContext context, AnalyzerOptions options, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
if (!nameEquals.Parent.IsKind(SyntaxKind.AnonymousObjectMemberDeclarator, out AnonymousObjectMemberDeclaratorSyntax? anonCtor))
{
return;
}
var preference = options.GetOption(
CodeStyleOptions.PreferInferredAnonymousTypeMemberNames, context.Compilation.Language, syntaxTree, cancellationToken);
if (!preference.Value ||
!CSharpInferredMemberNameReducer.CanSimplifyAnonymousTypeMemberName(anonCtor))
{
return;
}
// Create a normal diagnostic
context.ReportDiagnostic(
DiagnosticHelper.Create(
Descriptor,
nameEquals.GetLocation(),
preference.Notification.Severity,
additionalLocations: null,
properties: null));
// Also fade out the part of the name-equals syntax
RoslynDebug.AssertNotNull(UnnecessaryWithoutSuggestionDescriptor);
var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);
context.ReportDiagnostic(
Diagnostic.Create(
UnnecessaryWithoutSuggestionDescriptor,
syntaxTree.GetLocation(fadeSpan)));
}
private void ReportDiagnosticsIfNeeded(NameEqualsSyntax nameEquals, SyntaxNodeAnalysisContext context, OptionSet optionSet, SyntaxTree syntaxTree)
{
if (!nameEquals.IsParentKind(SyntaxKind.AnonymousObjectMemberDeclarator))
{
return;
}
var anonCtor = (AnonymousObjectMemberDeclaratorSyntax)nameEquals.Parent;
if (!optionSet.GetOption(CSharpCodeStyleOptions.PreferInferredAnonymousTypeMemberNames).Value ||
!CSharpInferredMemberNameReducer.CanSimplifyAnonymousTypeMemberName(anonCtor))
{
return;
}
// Create a normal diagnostic
context.ReportDiagnostic(
Diagnostic.Create(GetDescriptorWithSeverity(
optionSet.GetOption(CSharpCodeStyleOptions.PreferInferredAnonymousTypeMemberNames).Notification.Value),
nameEquals.GetLocation()));
// Also fade out the part of the name-equals syntax
var fadeSpan = TextSpan.FromBounds(nameEquals.Name.SpanStart, nameEquals.EqualsToken.Span.End);
context.ReportDiagnostic(
Diagnostic.Create(
UnnecessaryWithoutSuggestionDescriptor,
syntaxTree.GetLocation(fadeSpan)));
}
internal void Analyze(FileModel fileModel)
{
List <UsingDirectiveSyntax> usingDirectiveSyntaxes = SyntaxTree
.GetRoot()
.DescendantNodes()
.OfType <UsingDirectiveSyntax>()
.ToList();
foreach (UsingDirectiveSyntax usingDirectiveSyntax in usingDirectiveSyntaxes)
{
UsingModel usingModel = new UsingModel();
usingModel.Name = usingDirectiveSyntax.Name.ToString();
NameEqualsSyntax nameEqualsSyntax =
usingDirectiveSyntax.DescendantNodes().OfType <NameEqualsSyntax>().FirstOrDefault();
if (nameEqualsSyntax != null)
{
usingModel.Alias = nameEqualsSyntax.Name.ToString();
}
if (usingDirectiveSyntax.StaticKeyword.Text != "")
{
usingModel.Static = true;
}
fileModel.Usings.Add(usingModel);
}
}
public static void ComputeRefactoring(RefactoringContext context, UsingDirectiveSyntax usingDirective)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveUsingAliasDirective))
{
NameEqualsSyntax alias = usingDirective.Alias;
if (alias != null)
{
IdentifierNameSyntax name = alias.Name;
if (name != null && context.Span.IsContainedInSpanOrBetweenSpans(name))
{
context.RegisterRefactoring(
"Inline alias expression",
cancellationToken =>
{
return(RemoveUsingAliasDirectiveRefactoring.RefactorAsync(
context.Document,
usingDirective,
cancellationToken));
});
}
}
}
}
internal AliasSymbol(Binder binder, NameSyntax name, NameEqualsSyntax alias)
: this(binder, alias.Name.Identifier)
{
Debug.Assert(name.Parent.IsKind(SyntaxKind.UsingDirective));
Debug.Assert(name.Parent == alias.Parent);
_aliasTargetName = name;
}
public override void AddChildren()
{
Kind = Node.Kind();
_nameEquals = ((AnonymousObjectMemberDeclaratorSyntax)Node).NameEquals;
_nameEqualsIsChanged = false;
_expression = ((AnonymousObjectMemberDeclaratorSyntax)Node).Expression;
_expressionIsChanged = false;
}
private Doc PrintNameEqualsSyntax(NameEqualsSyntax node)
{
return(Concat(
this.Print(node.Name),
SpaceIfNoPreviousComment,
this.PrintSyntaxToken(node.EqualsToken, " ")
));
}
public static Doc Print(NameEqualsSyntax node)
{
return(Doc.Concat(
Node.Print(node.Name),
" ",
Token.PrintWithSuffix(node.EqualsToken, " ")
));
}
public bool Analyze(NameEqualsSyntax syntax)
{
if (!(syntax.Parent is AttributeArgumentSyntax) && !(syntax.Parent is UsingDirectiveSyntax))
{
FireSyntaxErrorCallback(syntax, "You cannot set type elements in this mannor");
return(false);
}
return(true);
}
private static NameColonSyntax ConvertName(NameEqualsSyntax nameEquals) =>
nameEquals == null
? null
: SyntaxFactory.NameColon(
nameEquals.Name,
SyntaxFactory
.Token(SyntaxKind.ColonToken)
.WithTriviaFrom(nameEquals.EqualsToken)
);
public override void AddChildren()
{
Kind = Node.Kind();
_nameEquals = ((AttributeArgumentSyntax)Node).NameEquals;
_nameEqualsIsChanged = false;
_nameColon = ((AttributeArgumentSyntax)Node).NameColon;
_nameColonIsChanged = false;
_expression = ((AttributeArgumentSyntax)Node).Expression;
_expressionIsChanged = false;
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Name?.Accept(this);
base.VisitNameEquals(node);
PostVisit(node);
}
public override void AddChildren()
{
Kind = Node.Kind();
_usingKeyword = ((UsingDirectiveSyntax)Node).UsingKeyword;
_usingKeywordIsChanged = false;
_staticKeyword = ((UsingDirectiveSyntax)Node).StaticKeyword;
_staticKeywordIsChanged = false;
_alias = ((UsingDirectiveSyntax)Node).Alias;
_aliasIsChanged = false;
_name = ((UsingDirectiveSyntax)Node).Name;
_nameIsChanged = false;
_semicolonToken = ((UsingDirectiveSyntax)Node).SemicolonToken;
_semicolonTokenIsChanged = false;
}
private AnnotationArgumentSyntax ParseAnnotationArgument(ref bool shouldHaveName)
{
// Need to parse both "real" named arguments and _annotation-style named arguments.
// We track _annotation-style named arguments only with fShouldHaveName.
NameEqualsSyntax nameEquals = null;
NameColonSyntax nameColon = null;
if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken)
{
SyntaxKind nextTokenKind = this.PeekToken(1).Kind;
switch (nextTokenKind)
{
case SyntaxKind.EqualsToken:
{
var name = this.ParseIdentifierToken();
var equals = this.EatToken(SyntaxKind.EqualsToken);
nameEquals = _syntaxFactory.NameEquals(_syntaxFactory.IdentifierName(name), equals);
shouldHaveName = true;
}
break;
case SyntaxKind.ColonToken:
{
var name = this.ParseIdentifierName();
var colonToken = this.EatToken(SyntaxKind.ColonToken);
nameColon = _syntaxFactory.NameColon(name, colonToken);
nameColon = CheckFeatureAvailability(nameColon, MessageID.IDS_FeatureNamedArgument);
}
break;
}
}
var expr = this.ParseExpression();
// Not named -- give an error if it's supposed to be
if (shouldHaveName && nameEquals == null)
{
expr = this.AddError(expr, ErrorCode.ERR_NamedArgumentExpected);
}
return(_syntaxFactory.AnnotationArgument(nameEquals, nameColon, expr));
}
private AnonymousObjectMemberDeclaratorSyntax ParseAnonymousTypeMemberInitializer()
{
bool isNamedAssignment = this.IsNamedAssignment();
NameEqualsSyntax nameEquals = null;
if (isNamedAssignment)
{
nameEquals = ParseNameEquals();
}
var expression = this.ParseExpression();
if (!isNamedAssignment && !IsAnonymousTypeMemberExpression(expression))
{
expression = this.AddError(expression, ErrorCode.ERR_InvalidAnonymousTypeMemberDeclarator);
}
return(_syntaxFactory.AnonymousObjectMemberDeclarator(nameEquals, expression));
}
private static void ParseSelectValueAttributeArguments(AttributeArgumentListSyntax args, ref rSelectItem selfld)
{
foreach (var argument in args.Arguments)
{
NameEqualsSyntax nameEqSyntax = argument.NameEquals;
LiteralExpressionSyntax exprSyntax = (LiteralExpressionSyntax)argument.Expression;
IdentifierNameSyntax argName = (IdentifierNameSyntax)nameEqSyntax.Name;
if (argName.Identifier.Text == "Description")
{
selfld.Description = exprSyntax.Token.Text;
}
else if (argName.Identifier.Text == "Label")
{
selfld.Label = exprSyntax.Token.Text;
}
// else if (argName.Identifier.Text == "Default")
// selfld.Default = exprSyntax.Token.Text == "true" ? true : false;
}
}
private static void ParseBitfieldValueAttributeArguments(AttributeArgumentListSyntax args, ref BitfieldField field)
{
foreach (var argument in args.Arguments)
{
NameEqualsSyntax nameEqSyntax = argument.NameEquals;
LiteralExpressionSyntax exprSyntax = (LiteralExpressionSyntax)argument.Expression;
IdentifierNameSyntax argName = (IdentifierNameSyntax)nameEqSyntax.Name;
if (argName.Identifier.Text == "Description")
{
field.Description = exprSyntax.Token.Text;
}
else if (argName.Identifier.Text == "Label")
{
field.Label = exprSyntax.Token.Text;
}
else if (argName.Identifier.Text == "Empty")
{
field.Empty = exprSyntax.Token.Text == "true" ? true : false;
}
}
}
public static void ParseAttributes(AttributeArgumentListSyntax args, ref BitfieldDefinition def)
{
if (args == null)
{
return;
}
foreach (var argument in args.Arguments)
{
NameEqualsSyntax nameEqSyntax = argument.NameEquals;
LiteralExpressionSyntax exprSyntax = (LiteralExpressionSyntax)argument.Expression;
IdentifierNameSyntax argName = (IdentifierNameSyntax)nameEqSyntax.Name;
if (argName.Identifier.Text == "Description")
{
def.Description = exprSyntax.Token.Text;
}
else if (argName.Identifier.Text == "Label")
{
def.Label = exprSyntax.Token.Text;
}
Console.Error.WriteLine("");
}
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
node.Name?.Accept(this);
base.VisitNameEquals(node);
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
Name = node.Name.ToString();
base.VisitNameEquals(node);
}
public override Evaluation VisitNameEquals(NameEqualsSyntax node)
{
node.Name?.Accept <Evaluation>(this);
return(base.VisitNameEquals(node));
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
throw new NotImplementedException();
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
foreach (var diagnostic in context.Diagnostics)
{
if (!string.Equals(diagnostic.Id, JsonPropertyDefaultValueHandlingAnalyzer.DiagnosticId, StringComparison.Ordinal))
{
continue;
}
var documentRoot = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
AttributeSyntax syntax = documentRoot.FindNode(diagnostic.Location.SourceSpan) as AttributeSyntax;
if (syntax == null)
{
continue;
}
ExpressionSyntax expression =
SyntaxFactory.ParseExpression("global::Newtonsoft.Json.DefaultValueHandling.Ignore")
.WithAdditionalAnnotations(Simplifier.Annotation);
AttributeSyntax newAttribute = null;
AttributeArgumentListSyntax argumentList = syntax.ArgumentList;
if (argumentList != null)
{
AttributeArgumentSyntax existingArgument = null;
foreach (var attributeArgument in argumentList.Arguments)
{
if (string.Equals("DefaultValueHandling", attributeArgument.NameEquals?.Name?.Identifier.ValueText, StringComparison.Ordinal))
{
existingArgument = attributeArgument;
break;
}
}
if (existingArgument != null)
{
var newArgument =
existingArgument
.WithExpression(expression)
.WithTriviaFrom(existingArgument)
.WithoutFormatting();
newAttribute = syntax.ReplaceNode(existingArgument, newArgument);
}
}
if (newAttribute == null)
{
NameEqualsSyntax nameEquals = SyntaxFactory.NameEquals("DefaultValueHandling");
AttributeArgumentSyntax defaultValueArgument = SyntaxFactory.AttributeArgument(nameEquals, null, expression);
if (argumentList == null)
{
argumentList = SyntaxFactory.AttributeArgumentList();
}
argumentList = argumentList.AddArguments(defaultValueArgument);
newAttribute = syntax.WithArgumentList(argumentList);
}
SyntaxNode newRoot = documentRoot.ReplaceNode(syntax, newAttribute);
Document newDocument = context.Document.WithSyntaxRoot(newRoot);
context.RegisterCodeFix(CodeAction.Create("Add DefaultValueHandling.Ignore", _ => Task.FromResult(newDocument)), diagnostic);
}
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
base.VisitNameEquals(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitNameEquals(NameEqualsSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitNameEquals(node);
}
public void VisitNameEquals(NameEqualsSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
node.Name.Accept(this);
bool writeSpace;
if (node.Parent is UsingDirectiveSyntax)
writeSpace = _writer.Configuration.Spaces.Other.AroundEqualsInNamespaceAliasDirective;
else
writeSpace = true;
if (writeSpace)
_writer.WriteSpace();
_writer.WriteOperator(PrinterOperator.Equals);
if (writeSpace)
_writer.WriteSpace();
}
private IEnumerable<ITypeSymbol> InferTypeInNameEquals(NameEqualsSyntax nameEquals, SyntaxToken? previousToken = null)
{
if (previousToken == nameEquals.EqualsToken)
{
// we're on the right of the equals. Try to bind the left name to see if it
// gives us anything useful.
return GetTypes(nameEquals.Name);
}
var attributeArgumentSyntax = nameEquals.Parent as AttributeArgumentSyntax;
if (attributeArgumentSyntax != null)
{
var argumentExpression = attributeArgumentSyntax.Expression;
return this.GetTypes(argumentExpression);
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public override void VisitNameEquals(NameEqualsSyntax node)
{
IncrementNodeCount(1); // simple identifier
AddOperand(node.Name.Identifier.ValueText);
// intentionally do NOT call `base` so that identifier is not visited twice
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitNameEquals(NameEqualsSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitNameEquals(node);
}
private BoundExpression BindAnonymousObjectCreation(AnonymousObjectCreationExpressionSyntax node, DiagnosticBag diagnostics)
{
// prepare
var initializers = node.Initializers;
int fieldCount = initializers.Count;
bool hasError = false;
// bind field initializers
BoundExpression[] boundExpressions = new BoundExpression[fieldCount];
AnonymousTypeField[] fields = new AnonymousTypeField[fieldCount];
CSharpSyntaxNode[] fieldSyntaxNodes = new CSharpSyntaxNode[fieldCount];
// WARNING: Note that SemanticModel.GetDeclaredSymbol for field initializer node relies on
// the fact that the order of properties in anonymous type template corresponds
// 1-to-1 to the appropriate filed initializer syntax nodes; This means such
// correspondence must be preserved all the time including erroneos scenarios
// set of names already used
HashSet <string> uniqueFieldNames = new HashSet <string>();
for (int i = 0; i < fieldCount; i++)
{
AnonymousObjectMemberDeclaratorSyntax fieldInitializer = initializers[i];
NameEqualsSyntax nameEquals = fieldInitializer.NameEquals;
ExpressionSyntax expression = fieldInitializer.Expression;
SyntaxToken nameToken = default(SyntaxToken);
if (nameEquals != null)
{
nameToken = nameEquals.Name.Identifier;
}
else
{
nameToken = expression.ExtractAnonymousTypeMemberName();
}
hasError = hasError || expression.HasErrors;
boundExpressions[i] = this.BindValue(expression, diagnostics, BindValueKind.RValue);
// check the name to be unique
string fieldName = null;
if (nameToken.CSharpKind() == SyntaxKind.IdentifierToken)
{
fieldName = nameToken.ValueText;
if (uniqueFieldNames.Contains(fieldName))
{
// name duplication
Error(diagnostics, ErrorCode.ERR_AnonymousTypeDuplicatePropertyName, fieldInitializer);
hasError = true;
fieldName = null;
}
else
{
uniqueFieldNames.Add(fieldName);
}
}
else
{
// there is something wrong with field's name
hasError = true;
}
// calculate the expression's type and report errors if needed
TypeSymbol fieldType = GetAnonymousTypeFieldType(boundExpressions[i], fieldInitializer, diagnostics, ref hasError);
// build anonymous type field descriptor
fieldSyntaxNodes[i] = (nameToken.CSharpKind() == SyntaxKind.IdentifierToken) ? (CSharpSyntaxNode)nameToken.Parent : fieldInitializer;
fields[i] = new AnonymousTypeField(fieldName == null ? '$' + i.ToString() : fieldName, fieldSyntaxNodes[i].Location, fieldType);
// NOTE: ERR_InvalidAnonymousTypeMemberDeclarator (CS0746) would be generated by parser if needed
}
// Create anonymous type
AnonymousTypeManager manager = this.Compilation.AnonymousTypeManager;
AnonymousTypeDescriptor descriptor = new AnonymousTypeDescriptor(fields.AsImmutableOrNull(), node.NewKeyword.GetLocation());
NamedTypeSymbol anonymousType = manager.ConstructAnonymousTypeSymbol(descriptor);
// declarators - bound nodes created for providing semantic info
// on anonymous type fields having explicitly specified name
ArrayBuilder <BoundAnonymousPropertyDeclaration> declarators =
ArrayBuilder <BoundAnonymousPropertyDeclaration> .GetInstance();
for (int i = 0; i < fieldCount; i++)
{
NameEqualsSyntax explicitName = initializers[i].NameEquals;
if (explicitName != null)
{
AnonymousTypeField field = fields[i];
if (field.Name != null)
{
// get property symbol and create a bound property declaration node
foreach (var symbol in anonymousType.GetMembers(field.Name))
{
if (symbol.Kind == SymbolKind.Property)
{
declarators.Add(new BoundAnonymousPropertyDeclaration(fieldSyntaxNodes[i], (PropertySymbol)symbol, field.Type));
break;
}
}
}
}
}
// check if anonymous object creation is allowed in this context
if (!this.IsAnonymousTypesAllowed())
{
Error(diagnostics, ErrorCode.ERR_AnonymousTypeNotAvailable, node.NewKeyword);
hasError = true;
}
// Finally create a bound node
return(new BoundAnonymousObjectCreationExpression(
node,
anonymousType.InstanceConstructors[0],
boundExpressions.AsImmutableOrNull(),
declarators.ToImmutableAndFree(),
anonymousType,
hasError));
}
public override LuaSyntaxNode VisitNameEquals(NameEqualsSyntax node)
{
return(node.Name.Accept(this));
}
