public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { var declaration = (TypeDeclarationSyntax)base.VisitClassDeclaration(node); var guid = Guid.NewGuid().ToString(); var containerProviderAttribute = SyntaxFactory .AttributeList ( SyntaxFactory.SingletonSeparatedList ( SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("ContainerProvider")) .WithArgumentList ( SyntaxFactory.AttributeArgumentList ( SyntaxFactory.SingletonSeparatedList ( SyntaxFactory.AttributeArgument ( SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(guid)) ) ) ) ) ) ) .NormalizeWhitespace(); var newDeclaration = declaration.AddAttributeLists(containerProviderAttribute); return(newDeclaration); }
public static SyntaxList <AttributeListSyntax> BuildOperationContractAttributeForAsyncMethod(string existingServiceActionName, SyntaxList <AttributeListSyntax> existingAttributeLists) { var actionAttributeValue = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(existingServiceActionName)); var actionAttribute = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Action"), null, actionAttributeValue); var replyAttributeValue = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal($"{existingServiceActionName}Response")); var replyActionAttribute = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("ReplyAction"), null, replyAttributeValue); var separatedSyntaxListForAttribArgs = new SeparatedSyntaxList <AttributeArgumentSyntax>(); separatedSyntaxListForAttribArgs = separatedSyntaxListForAttribArgs.Add(actionAttribute); separatedSyntaxListForAttribArgs = separatedSyntaxListForAttribArgs.Add(replyActionAttribute); var attributeArgs = SyntaxFactory.AttributeArgumentList(separatedSyntaxListForAttribArgs); var operationContractAttribute = existingAttributeLists.First().Attributes.First(); var newOperationContractAttribute = operationContractAttribute.WithArgumentList(attributeArgs); var separatedAttributeList = SyntaxFactory.SeparatedList <AttributeSyntax>(); separatedAttributeList = separatedAttributeList.Add(newOperationContractAttribute); var attrList = SyntaxFactory.AttributeList(separatedAttributeList); var yetAnotherFuckingList = new SyntaxList <AttributeListSyntax>(); yetAnotherFuckingList = yetAnotherFuckingList.Add(attrList); return(yetAnotherFuckingList); }
private AttributeListSyntax GenerateTermAttribute(FieldType metaData, IGeneratorConfiguration config) { LiteralExpressionSyntax literalExpression = null; switch (config.TermAttribute) { case TermAttributeType.name: literalExpression = SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(metaData.Term)); break; case TermAttributeType.index: literalExpression = SyntaxFactory.LiteralExpression( SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(metaData.Index)); break; default: throw new Exception("Invalid term attribute configuration"); } ; return(SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("Term")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument(literalExpression))))))); }
private static async Task <Document> AddFriendClassAttributeAsync(Document document, ClassDeclarationSyntax?classDeclaration, string friendClassType, CancellationToken cancellationToken) { // 构造FriendClassAttribute 语法节点 AttributeArgumentSyntax attributeArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.TypeOfExpression(SyntaxFactory.ParseTypeName(friendClassType))); AttributeSyntax attributeSyntax = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("FriendClassAttribute")) .WithArgumentList(SyntaxFactory.AttributeArgumentList(SyntaxFactory.SingletonSeparatedList(attributeArgument))); // 构造添加构造FriendClassAttribute 得AttributeList语法节点 SyntaxList <AttributeListSyntax>?attributes = classDeclaration?.AttributeLists.Add( SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attributeSyntax)).NormalizeWhitespace()); if (attributes == null) { return(document); } // 构造替换AttributeList的 ClassDeclaration语法节点 ClassDeclarationSyntax?newClassDeclaration = classDeclaration?.WithAttributeLists(attributes.Value).WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode?root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); if (root == null || classDeclaration == null || newClassDeclaration == null) { return(document); } // 构造替换classDeclaration的root语法节点 var newRoot = root.ReplaceNode(classDeclaration, newClassDeclaration); // 替换root语法节点 return(document.WithSyntaxRoot(newRoot)); }
public static Task <Document> Fix( Document orig, SyntaxNode root, AttributeSyntax attr, string maxExceptionsAllowed ) { var syntaxForExcepts = maxExceptionsAllowed .Split(',') .Select(GetSyntaxForExceptName) .ToImmutableArray(); var expr = CombineReasons(syntaxForExcepts); // newAttr will always have fewer exceptions than attr: see the // note in the analyzer attached to maximalExceptions var newAttr = attr.WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument( expr ).WithNameEquals(SyntaxFactory.NameEquals("Except")) ) ) ); var newRoot = root.ReplaceNode(attr, newAttr); var newDoc = orig.WithSyntaxRoot(newRoot); return(Task.FromResult(newDoc)); }
public SyntaxList <AttributeListSyntax> Convert( SyntaxList <AttributeListSyntax> attributeList, bool isSkip, string skipText) { var attributes = attributeList.First(a => a.Attributes.Any(at => at.Name.ToString().Equals("Test", StringComparison.OrdinalIgnoreCase))); var attribute = attributes.Attributes.First(at => at.Name.ToString().Equals("Test", StringComparison.OrdinalIgnoreCase)); var newAttribute = attribute.WithName(SyntaxFactory.IdentifierName("Fact")); if (isSkip) { newAttribute = newAttribute.WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList(new[] { SyntaxFactory.AttributeArgument( SyntaxFactory.NameEquals("Skip"), null, SyntaxFactory.IdentifierName(skipText)) }))); } return(attributeList.Replace(attributes, attributes.WithAttributes( attributes.Attributes.Replace(attribute, newAttribute)))); }
private AttributeSyntax TransformExplicitAttribute(AttributeSyntax node) { var location = node.GetLocation(); var original = node.ToFullString(); // MSTest V2 does not support "[Explicit]". // Convert "[Explicit]" to "[Ignore("EXPLICIT")]" // Convert "[Explicit("yadayada")]" to "[Ignore("EXPLICIT: yadayada")]" string text = "EXPLICIT"; var description = node.GetPositionExpression(0); if (description != null) { text += ": " + description.GetFirstToken().ValueText; } var literalExpression = SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("\"" + text + "\"", text)); var arguments = new SeparatedSyntaxList <AttributeArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.AttributeArgument(literalExpression)); node = node.WithName(SyntaxFactory.IdentifierName("Ignore")).WithArgumentList( SyntaxFactory.AttributeArgumentList(arguments)); m_diagnostics.Add(Diagnostic.Create(DiagnosticsDescriptors.TransformedUnsupported, location, original, node.ToFullString())); return(node); }
private AttributeSyntax GetRouteAttributeForWebmethod(string routeName, SemanticModel semanticModel, IEnumerable <ParameterSyntax> routeParams) { var parameters = new List <String>(); foreach (var routeParam in routeParams) { var paramName = routeParam.Identifier.Text; parameters.Add($"{{{paramName}}}"); } var route = $"{routeName}"; if (routeParams.Any()) { route = $"{route}/{String.Join("/", parameters)}"; } return(SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("Route")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SingletonSeparatedList <AttributeArgumentSyntax>( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal($"{route}"))))))); }
public static InterfaceDeclarationSyntax AddGeneratedCodeAttribute(this InterfaceDeclarationSyntax interfaceDeclaration, string toolName, string version) { if (interfaceDeclaration == null) { throw new ArgumentNullException(nameof(interfaceDeclaration)); } if (toolName == null) { throw new ArgumentNullException(nameof(toolName)); } if (version == null) { throw new ArgumentNullException(nameof(version)); } var attributeArgumentList = SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList( SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(toolName)), SyntaxTokenFactory.Comma(), SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(version))))); return(interfaceDeclaration .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(GeneratedCodeAttribute), attributeArgumentList))); }
public static ClassDeclarationSyntax AddDataAnnotation(this ClassDeclarationSyntax cls, string annotationKey, string annotationValue, string parameter, string parameterValues) { return(cls.WithAttributeLists( SyntaxFactory.SingletonList <AttributeListSyntax>( SyntaxFactory.AttributeList( SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Attribute(SyntaxFactory.ParseName(annotationKey), SyntaxFactory.AttributeArgumentList( SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(new[] { SyntaxFactory.AttributeArgument(SyntaxFactory.IdentifierName(annotationValue)), SyntaxFactory.AttributeArgument( SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(parameter), SyntaxFactory.Token(SyntaxKind.EqualsToken)), null, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(parameterValues)) ) }), SyntaxFactory.Token(SyntaxKind.CloseParenToken) ) ) } ) ) ) )); }
public SyntaxList <AttributeListSyntax> AddIniOptionsAttributeToProperty(string section, string key) { return(SyntaxFactory.SingletonList <AttributeListSyntax>( SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList <AttributeSyntax>( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("IniOptions")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(section))) .WithNameEquals( SyntaxFactory.NameEquals( SyntaxFactory.IdentifierName("Section"))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(key))) .WithNameEquals( SyntaxFactory.NameEquals( SyntaxFactory.IdentifierName("Key"))) }))))))); }
public override SyntaxNode MakeSyntaxNode() { var res = SyntaxFactory.AttributeArgumentList(OpenParenToken, Arguments, CloseParenToken); IsChanged = false; return(res); }
public override PropertyDeclarationSyntax GetSyntax() { var format = DateFormat == "date" ? TypeHelpers.PythonDateFormatString : TypeHelpers.DateTimeFormatString; var syntax = base.GetSyntax(); return(syntax.WithAttributeLists( SyntaxFactory.SingletonList <AttributeListSyntax>( SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList <AttributeSyntax>( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName("JsonConverter")) .WithArgumentList( SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList <AttributeArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.AttributeArgument( SyntaxFactory.TypeOfExpression( SyntaxFactory.IdentifierName("CustomDateConverter"))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(format))) })))))))); }
private static AttributeArgumentListSyntax?GenerateAttributeArgumentList( AttributeData attribute ) { if (attribute.ConstructorArguments.Length == 0 && attribute.NamedArguments.Length == 0) { return(null); } var arguments = new List <AttributeArgumentSyntax>(); arguments.AddRange( attribute.ConstructorArguments.Select( c => SyntaxFactory.AttributeArgument(ExpressionGenerator.GenerateExpression(c)) ) ); arguments.AddRange( attribute.NamedArguments.Select( kvp => SyntaxFactory.AttributeArgument( SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(kvp.Key)), null, ExpressionGenerator.GenerateExpression(kvp.Value) ) ) ); return(SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(arguments))); }
private async static Task <Document> ChangeAttribute(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { if (diagnostic.Properties.TryGetValue("numericValue", out var value) && diagnostic.Properties.TryGetValue("type", out var type)) { var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var variable = root.FindNode(diagnostic.Location.SourceSpan) as VariableDeclaratorSyntax; var attributeArgument = SyntaxFactory.AttributeArgument( null, null, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, CreateMagicStringValue(value, type))); var attribute = ((FieldDeclarationSyntax)variable.Parent.Parent).AttributeLists.First(); var newAttribute = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("MagicNumber")) .WithArgumentList(SyntaxFactory.AttributeArgumentList(SyntaxFactory.SingletonSeparatedList(attributeArgument)))) ) .WithTriviaFrom(attribute); var newRoot = root.ReplaceNode(attribute, newAttribute); document = document.WithSyntaxRoot(newRoot); } return(document); }
private async Task <Solution> CreateTestCategoryAttribute(Document document, Diagnostic diagnostic, MethodDeclarationSyntax methodDeclaration, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken); var frameworkAnalyzerUsed = FrameworkAnalyzers.FirstOrDefault(analyzer => analyzer.GetType().FullName == diagnostic.Properties[nameof(IFrameworkAnalyzer)]); string testCategoryAttribute = frameworkAnalyzerUsed.TestCategoryAttribute; SyntaxNodeOrTokenList attributeArguments = frameworkAnalyzerUsed.GetTestCategoryAttributeArguments(); var currentIndent = methodDeclaration.GetLeadingTrivia().Where(t => t.IsKind(SyntaxKind.WhitespaceTrivia)); var attributes = methodDeclaration.AttributeLists.Add( SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute( SyntaxFactory.IdentifierName(testCategoryAttribute)) .WithArgumentList(SyntaxFactory .AttributeArgumentList(SyntaxFactory .SeparatedList <AttributeArgumentSyntax>(attributeArguments))) )).NormalizeWhitespace() .WithLeadingTrivia(currentIndent) .WithTrailingTrivia(SyntaxFactory.Whitespace(Environment.NewLine))); document = document.WithSyntaxRoot( root.ReplaceNode( methodDeclaration, methodDeclaration.WithAttributeLists(attributes) )); return(document.Project.Solution); }
public override SyntaxNode VisitAttributeList(AttributeListSyntax node) { // Override ettiğimi fonksiyon içerisinde Metotlara uygulanan Attribute'ları dolaşıyoruz. if (node.Parent is MethodDeclarationSyntax && node.Attributes.Any(attr => attr.Name.GetText().ToString() == "WSATEnable")) { /* * Aşağıdaki kod parçasında WSATEnable niteliği için yeni bir argüman listesi oluşturuyoruz. * Buna göre Niteliğin adı yine WSATEnable. * Diğer yandan Active parametresini false, * Target parametresini de MQ olarak değiştirmekteyiz. */ return(SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("WSATEnable"), SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList(new[] { SyntaxFactory.AttributeArgument( nameEquals: SyntaxFactory.NameEquals("Active"), nameColon: null, SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)), SyntaxFactory.AttributeArgument( nameEquals: SyntaxFactory.NameEquals("Target"), nameColon: null, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(@"MQ"))) }))))).WithTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed)); // ElasticCarriageReturnLineFeed ile alt satır inilmesini sağladık. Aksi durumda class ile attribute aynı satırda oluyordu. } // Tabii if koşuluna uymayan bir ifade ile karşılaştıysak yolumuza devam ediyoruz return(base.VisitAttributeList(node)); }
private AttributeArgumentListSyntax CreateAttributeArguments(ISymbol targetSymbol, Diagnostic diagnostic) { // SuppressMessage("Rule Category", "Rule Id", Justification = nameof(Justification), Scope = nameof(Scope), Target = nameof(Target)) var category = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(diagnostic.Descriptor.Category)); var categoryArgument = SyntaxFactory.AttributeArgument(category); var title = diagnostic.Descriptor.Title.ToString(CultureInfo.CurrentUICulture); var ruleIdText = string.IsNullOrWhiteSpace(title) ? diagnostic.Id : string.Format("{0}:{1}", diagnostic.Id, title); var ruleId = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(ruleIdText)); var ruleIdArgument = SyntaxFactory.AttributeArgument(ruleId); var justificationExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(FeaturesResources.Pending)); var justificationArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Justification"), nameColon: null, expression: justificationExpr); var attributeArgumentList = SyntaxFactory.AttributeArgumentList().AddArguments(categoryArgument, ruleIdArgument, justificationArgument); var scopeString = GetScopeString(targetSymbol.Kind); if (scopeString != null) { var scopeExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(scopeString)); var scopeArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Scope"), nameColon: null, expression: scopeExpr); var targetString = GetTargetString(targetSymbol); var targetExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(targetString)); var targetArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Target"), nameColon: null, expression: targetExpr); attributeArgumentList = attributeArgumentList.AddArguments(scopeArgument, targetArgument); } return(attributeArgumentList); }
private IEnumerable <SyntaxNode> BuildSyntax(IAttribute item) { var itemAsT = item as IAttribute; var nameSyntax = SyntaxFactory.ParseName(itemAsT.Name); var node = SyntaxFactory.Attribute(nameSyntax); node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup); var attributeArgList = itemAsT.AttributeValues .SelectMany(x => RDom.CSharp.GetSyntaxGroup(x)) .OfType <AttributeArgumentSyntax>() .ToList(); if (attributeArgList.Any()) { var argList = SyntaxFactory.AttributeArgumentList( SyntaxFactory.SeparatedList(attributeArgList)); argList = BuildSyntaxHelpers.AttachWhitespace(argList, item.Whitespace2Set, WhitespaceLookup); node = node.WithArgumentList(argList); } var nodeList = SyntaxFactory.AttributeList( SyntaxFactory.SeparatedList( new AttributeSyntax[] { (AttributeSyntax)BuildSyntaxHelpers.PrepareForBuildItemSyntaxOutput(node, item, OutputContext) })); nodeList = BuildSyntaxHelpers.AttachWhitespace(nodeList, item.Whitespace2Set, WhitespaceLookup); return(nodeList.PrepareForBuildSyntaxOutput(item, OutputContext)); }
private async Task <Document> GetTransformedDocumentAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var declaration = root.FindToken(diagnostic.Location.SourceSpan.Start).Parent.AncestorsAndSelf().OfType <AttributeSyntax>().First(); var property = declaration.FirstAncestorOrSelf <PropertyDeclarationSyntax>(); var maxOrderNumber = property.GetMaxOrderNumber(); var newList = declaration.ArgumentList ?? SyntaxFactory.AttributeArgumentList(); newList = newList.WithArguments( SyntaxFactory.SeparatedList(newList.Arguments.Add( SyntaxFactory.AttributeArgument( SyntaxFactory.NameEquals("Order"), null, SyntaxFactory.ParseExpression($"{maxOrderNumber + 1}"))))); var newDeclaration = declaration.WithArgumentList(newList); var newRoot = root.ReplaceNode(declaration, newDeclaration); return(document.WithSyntaxRoot(newRoot)); }
private async Task <Solution> AddSwaggerOperationAttribute(Document document, MethodDeclarationSyntax methodDeclaration, CancellationToken cancellationToken) { var attributeValue = GetAttributeValue(methodDeclaration); var liralExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.StringLiteralToken, attributeValue, attributeValue, default(SyntaxTriviaList))); var attributeArgument = SyntaxFactory.AttributeArgument(liralExpression); var attributeList = new SeparatedSyntaxList <AttributeArgumentSyntax>(); attributeList = attributeList.Add(attributeArgument); var argumentList = SyntaxFactory.AttributeArgumentList(attributeList); var attributes = methodDeclaration.AttributeLists.Add( SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList <AttributeSyntax>( SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(swaggerOperationAttributeName)) .WithArgumentList(argumentList) ) ) ); var root = await document.GetSyntaxRootAsync(cancellationToken); return(document.WithSyntaxRoot( root.ReplaceNode( methodDeclaration, methodDeclaration.WithAttributeLists(attributes) )).Project.Solution); }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { var identifierToken = node.Identifier.ToString(); var leadingTrivia = node.GetLeadingTrivia(); var obsoleteExpression = SyntaxFactory.AttributeList ( SyntaxFactory.SingletonSeparatedList <AttributeSyntax> ( SyntaxFactory.Attribute ( SyntaxFactory.IdentifierName("Obsolete") ) .WithArgumentList ( SyntaxFactory.AttributeArgumentList ( SyntaxFactory.SingletonSeparatedList <AttributeArgumentSyntax> ( SyntaxFactory.AttributeArgument ( SyntaxFactory.LiteralExpression ( SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Use " + identifierToken[0].ToString().ToUpper() + identifierToken.Substring(1) + " instead") ) ) ) ) ) ) ).WithLeadingTrivia(leadingTrivia); //char.IsLower(identifierToken[0]) if (identifierToken[0] >= 'a' && identifierToken[0] <= 'z') { //identifierToken[0].ToString().ToUpper(); /* var obsoleteExpression = * SyntaxFactory.AttributeList( * SyntaxFactory.Attribute( * SyntaxFactory.IdentifierName("Obsolete").WithLeadingTrivia(leadingTrivia)), * SyntaxFactory.AttributeArgumentList( * SyntaxFactory.SingletonSeparatedList<AttributeArgumentSyntax>( * SyntaxFactory.AttributeArgument( * SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.Identifier) * * * ))))); */ node = node.AddAttributeLists(obsoleteExpression); } return(base.VisitClassDeclaration(node)); }
public DummyRewriter() { var expArg = SyntaxFactory.AttributeArgument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("EXP"))); var conditionalArgs = SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(new[] { expArg })); var conditionalAttr = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Conditional"), conditionalArgs); conditionalAttributeSyntax = SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new[] { conditionalAttr })); }
private static AttributeSyntax CreateProducesResponseTypeAttribute(int statusCode) { return(SyntaxFactory.Attribute( SyntaxFactory.ParseName(ApiSymbolNames.ProducesResponseTypeAttribute) .WithAdditionalAnnotations(Simplifier.Annotation), SyntaxFactory.AttributeArgumentList().AddArguments( SyntaxFactory.AttributeArgument( SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(statusCode)))))); }
private static AttributeSyntax CreateProducesResponseTypeAttribute(CodeActionContext context, int statusCode, out bool addUsingDirective) { var statusCodeSyntax = CreateStatusCodeSyntax(context, statusCode, out addUsingDirective); return(SyntaxFactory.Attribute( SyntaxFactory.ParseName(ApiSymbolNames.ProducesResponseTypeAttribute) .WithAdditionalAnnotations(Simplifier.Annotation), SyntaxFactory.AttributeArgumentList().AddArguments( SyntaxFactory.AttributeArgument(statusCodeSyntax)))); }
private SeparatedSyntaxList <AttributeSyntax> CreateAttribute(SeparatedSyntaxList <AttributeArgumentSyntax> arguments) { AttributeArgumentListSyntax newArguments = SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); SeparatedSyntaxList <AttributeSyntax> attributeWhole = new SeparatedSyntaxList <AttributeSyntax>(); attributeWhole = attributeWhole.Add( SyntaxFactory.Attribute(SyntaxFactory.ParseName(AttributeName), newArguments)); return(attributeWhole); }
private static AttributeArgumentListSyntax GetAttributeArgumentListSyntax(List <AttributeArgumentData> arguments) { var argumentListSyntax = SyntaxFactory.AttributeArgumentList(); for (int i = 0, count = arguments.Count; i < count; i++) { argumentListSyntax = argumentListSyntax.AddArguments(GetAttributeArgumentSyntax(arguments[i])); } return(argumentListSyntax); }
private static SyntaxNode Snooze(SyntaxNode root, AttributeSyntax attributeSyntax, string message) { var newMessage = ObsoleteAfterAnalyzer.Regex.Replace(message, $"{DateTime.Now.AddDays(1):yyyy-MM-dd}"); var newAttribute = attributeSyntax .WithArgumentList(SyntaxFactory.AttributeArgumentList()) .AddArgumentListArguments(SyntaxFactory.AttributeArgument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(newMessage)))) .NormalizeWhitespace(); return root.ReplaceNode(attributeSyntax, newAttribute); }
protected AttributeListSyntax GetTypeAttributes(string typeName) { var attributeArguments = SyntaxFactory.SingletonSeparatedList( SyntaxFactory.AttributeArgument(SyntaxFactory.ParseExpression($"\"{typeName}\""))); var attribute = SyntaxFactory.Attribute( SyntaxFactory.ParseName("GraphQLType"), SyntaxFactory.AttributeArgumentList(attributeArguments)); return(SyntaxFactory.AttributeList( SyntaxFactory.SingletonSeparatedList(attribute))); }
private AttributeSyntax GenerateStructLayout() { var arg = SyntaxFactory.AttributeArgument( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(nameof(LayoutKind)), SyntaxFactory.IdentifierName(nameof(LayoutKind.Sequential)))); return(SyntaxFactory.Attribute( SyntaxFactory.ParseName("System.Runtime.InteropServices.StructLayoutAttribute"), SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(new[] { arg })))); }