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