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)))))));
        }
Beispiel #2
0
        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));
        }
Beispiel #4
0
        static CodeAction CreateAttributeCodeAction(Document document, SyntaxNode root, ExpressionSyntax node, IMethodSymbol constructor, AttributeSyntax attribute)
        {
            var arguments = attribute.ArgumentList.Arguments;
            var idx       = arguments.IndexOf(node.Parent as AttributeArgumentSyntax);

            var name = constructor.Parameters[idx].Name;

            return(CodeActionFactory.Create(
                       node.Span,
                       DiagnosticSeverity.Info,
                       string.Format(GettextCatalog.GetString("Add argument name '{0}'"), name),
                       t2 =>
            {
                var newArguments = SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(
                    attribute.ArgumentList.Arguments.Take(idx).Concat(
                        attribute.ArgumentList.Arguments.Skip(idx).Select((arg, i) =>
                {
                    if (arg.NameEquals != null)
                    {
                        return arg;
                    }
                    return SyntaxFactory.AttributeArgument(null, SyntaxFactory.NameColon(constructor.Parameters[i + idx].Name), arg.Expression);
                })
                        )
                    );
                var newAttribute = attribute.WithArgumentList(attribute.ArgumentList.WithArguments(newArguments));
                var newRoot = root.ReplaceNode((SyntaxNode)attribute, newAttribute).WithAdditionalAnnotations(Formatter.Annotation);
                return Task.FromResult(document.WithSyntaxRoot(newRoot));
            }
                       ));
        }
        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);
        }
Beispiel #6
0
        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));
        }
Beispiel #7
0
        private static AttributeListSyntax CreateAttribute(string fieldName)
        {
            AttributeArgumentSyntax arg  = SyntaxFactory.AttributeArgument(SyntaxFactory.ParseExpression("\"" + fieldName + "\""));
            AttributeSyntax         attr = SyntaxFactory.Attribute(SyntaxFactory.ParseName("XmlAttribute")).AddArgumentListArguments(arg);

            return(SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new[] { attr })));
        }
        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)))
            }))))))));
        }
Beispiel #9
0
        private static void AddRouteAttribute(SemanticModel semanticModel, SyntaxNode root, DocumentEditor documentEditor, TextSpan diagnosticSpan, CancellationToken cancellationToken)
        {
            var methodDeclaration = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType <MethodDeclarationSyntax>().First();

            var    method = semanticModel.GetDeclaredSymbol(methodDeclaration, cancellationToken);
            string?route  = null;

            foreach (var parameter in method.Parameters)
            {
                // Simple types participate in overload selection. We'll assume they all come from route and use it to produce a route for this action.
                // https://github.com/aspnet/AspNetWebStack/blob/749384689e027a2fcd29eb79a9137b94cea611a8/src/System.Web.Http/Internal/TypeHelper.cs#L63-L72
                if (parameter.Type.IsValueType ||
                    SymbolEqualityComparer.Default.Equals(parameter.Type, semanticModel.Compilation.GetSpecialType(SpecialType.System_String)) ||
                    SymbolEqualityComparer.Default.Equals(parameter.Type, semanticModel.Compilation.GetSpecialType(SpecialType.System_DateTime)) ||
                    SymbolEqualityComparer.Default.Equals(parameter.Type, semanticModel.Compilation.GetSpecialType(SpecialType.System_Decimal)))
                {
                    route += $"/{{{parameter.Name}}}";
                }
            }

            if (route is null)
            {
                return;
            }

            route = "[controller]/[action]" + route;

            var actionAttribute = SyntaxFactory.Attribute(
                SyntaxFactory.ParseName("Microsoft.AspNetCore.Mvc.Route").WithAdditionalAnnotations(Simplifier.Annotation))
                                  .AddArgumentListArguments(
                SyntaxFactory.AttributeArgument(
                    SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(route))));

            documentEditor.AddAttribute(methodDeclaration, actionAttribute);
        }
Beispiel #10
0
        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 static ClassDeclarationSyntax AddSuppressMessageAttribute(this ClassDeclarationSyntax classDeclaration, SuppressMessageAttribute suppressMessage)
        {
            if (classDeclaration == null)
            {
                throw new ArgumentNullException(nameof(classDeclaration));
            }

            if (suppressMessage == null)
            {
                throw new ArgumentNullException(nameof(suppressMessage));
            }

            if (string.IsNullOrEmpty(suppressMessage.Justification))
            {
                throw new ArgumentException(nameof(suppressMessage.Justification));
            }

            var attributeArgumentList = SyntaxFactory.AttributeArgumentList(
                SyntaxFactory.SeparatedList <AttributeArgumentSyntax>(SyntaxFactory.NodeOrTokenList(
                                                                          SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Category)),
                                                                          SyntaxTokenFactory.Comma(),
                                                                          SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.CheckId)),
                                                                          SyntaxTokenFactory.Comma(),
                                                                          SyntaxFactory.AttributeArgument(SyntaxLiteralExpressionFactory.Create(suppressMessage.Justification !))
                                                                          .WithNameEquals(
                                                                              SyntaxNameEqualsFactory.Create(nameof(SuppressMessageAttribute.Justification))
                                                                              .WithEqualsToken(SyntaxTokenFactory.Equals())))));

            return(classDeclaration
                   .AddAttributeLists(SyntaxAttributeListFactory.Create(nameof(SuppressMessageAttribute), attributeArgumentList)));
        }
Beispiel #13
0
        public static T ApplyAttributes <T>(this T syntaxNode, string attributeName, params object[] attributeArguments) where T : MemberDeclarationSyntax
        {
            if (attributeName.EndsWith("Attribute", StringComparison.OrdinalIgnoreCase))
            {
                attributeName = attributeName.Substring(0, attributeName.LastIndexOf("Attribute"));
            }

            var nameSyntax = attributeName.ParseCSharpName();

            var seperatedList = SyntaxFactory.SeparatedList <AttributeSyntax>();
            var attributeList = SyntaxFactory.AttributeList(seperatedList);
            var attribute     = SyntaxFactory.Attribute(nameSyntax);

            if (null != attributeArguments && 0 < attributeArguments.Length)
            {
                List <AttributeArgumentSyntax> attributesSyntax = new List <AttributeArgumentSyntax>();

                foreach (var attributeArgument in attributeArguments)
                {
                    var literalExpression = Extensions.CreateLiteralExpression(attributeArgument);
                    var argument          = SyntaxFactory.AttributeArgument(literalExpression);
                    attributesSyntax.Add(argument);
                }

                attribute = attribute.AddArgumentListArguments(attributesSyntax.ToArray());
            }

            return((T)syntaxNode.AddAttributeLists(attributeList.AddAttributes(attribute)));
        }
Beispiel #14
0
        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);
        }
Beispiel #15
0
        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))));
        }
        public override SyntaxNode MakeSyntaxNode()
        {
            var res = SyntaxFactory.AttributeArgument(NameEquals, NameColon, Expression);

            IsChanged = false;
            return(res);
        }
Beispiel #17
0
        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 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);
            }
Beispiel #19
0
        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);
        }
        public void ParameterTest(string attributeName, string[] attributeParameters,
                                  [Frozen] Mock <IAttributeArgumentDefinitionFactory> attributeParameterDefinitionFactoryMock,
                                  AttributeDefinitionFactory factory)
        {
            Expression <Func <IAttributeArgumentDefinitionFactory, AttributeArgumentDefinition> >
            attributeParameterExpression = f =>
                                           f.CreateAttributeParameterFromSyntax(It.IsAny <AttributeArgumentSyntax>());

            attributeParameterDefinitionFactoryMock.Setup(attributeParameterExpression).Returns(() => null)
            .Verifiable();

            var attribute = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(attributeName));

            foreach (var attributeParameter in attributeParameters)
            {
                attribute = attribute.AddArgumentListArguments(
                    SyntaxFactory.AttributeArgument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                                                                    SyntaxFactory.Token(SyntaxFactory.TriviaList(), SyntaxKind.StringLiteralToken,
                                                                                                        attributeParameter, attributeParameter, SyntaxFactory.TriviaList()))));
            }

            var result = factory.CreateAttributeFromSyntax(attribute);


            Assert.Equal(attributeName, result.Name);
            Assert.Equal(attributeParameters.Length, result.Parameters.Length);
            attributeParameterDefinitionFactoryMock.Verify(attributeParameterExpression,
                                                           Times.Exactly(attributeParameters.Length));
        }
Beispiel #21
0
        public static AttributeSyntax AddQuotedArgument(this AttributeSyntax attributeSyntax, object value)
        {
            var expression = SyntaxFactory.ParseExpression(string.Format("\"{0}\"", value));
            var argument   = SyntaxFactory.AttributeArgument(expression);

            return(attributeSyntax.AddArgumentListArguments(argument));
        }
Beispiel #22
0
        public static AttributeSyntax AddArgument(this AttributeSyntax attributeSyntax, object value)
        {
            var expression = SyntaxFactory.ParseExpression(value.ToString());
            var argument   = SyntaxFactory.AttributeArgument(expression);

            return(attributeSyntax.AddArgumentListArguments(argument));
        }
Beispiel #23
0
        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));
        }
Beispiel #24
0
        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);
        }
Beispiel #25
0
        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);
        }
Beispiel #26
0
        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)));
        }
        public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
        {
            var itemAsT = item as IAttributeValue;

            var argNameSyntax = SyntaxFactory.IdentifierName(itemAsT.Name);

            argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirst(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]);
            argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToLast(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]);

            //var kind = Mappings.SyntaxKindFromLiteralKind(itemAsT.ValueType, itemAsT.Value);
            ExpressionSyntax expr = BuildSyntaxHelpers.BuildArgValueExpression(
                itemAsT.Value, itemAsT.ValueConstantIdentifier, itemAsT.ValueType);
            var node = SyntaxFactory.AttributeArgument(expr);

            if (itemAsT.Style == AttributeValueStyle.Colon)
            {
                var nameColon = SyntaxFactory.NameColon(argNameSyntax);
                nameColon = BuildSyntaxHelpers.AttachWhitespaceToLast(nameColon, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]);
                node      = node.WithNameColon(nameColon);
            }
            else if (itemAsT.Style == AttributeValueStyle.Equals)
            {
                var nameEquals = SyntaxFactory.NameEquals(argNameSyntax);
                nameEquals = BuildSyntaxHelpers.AttachWhitespaceToLast(nameEquals, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]);
                node       = node.WithNameEquals(nameEquals);
            }
            node = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(node, item.Whitespace2Set[LanguageElement.AttributeValueValue]);

            return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
        }
Beispiel #28
0
 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")))
     })))))));
 }
Beispiel #29
0
        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));
        }
        internal override Task <Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, Diagnostic diagnostic, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var charSetType   = WellKnownTypes.CharSet(model.Compilation);
            var dllImportType = WellKnownTypes.DllImportAttribute(model.Compilation);
            var marshalAsType = WellKnownTypes.MarshalAsAttribute(model.Compilation);
            var unmanagedType = WellKnownTypes.UnmanagedType(model.Compilation);

            if (charSetType == null || dllImportType == null || marshalAsType == null || unmanagedType == null)
            {
                return(Task.FromResult(document));
            }

            var syntaxFactoryService = document.Project.LanguageServices.GetService <SyntaxGenerator>();

            // return the unchanged root if no fix is available
            var newRoot = root;

            if (nodeToFix.Kind() == SyntaxKind.Attribute)
            {
                // could be either a [DllImport] or [MarshalAs] attribute
                var attribute     = (AttributeSyntax)nodeToFix;
                var attributeType = model.GetSymbolInfo(attribute).Symbol;
                var arguments     = attribute.ArgumentList.Arguments;
                if (dllImportType.Equals(attributeType.ContainingType))
                {
                    // [DllImport] attribute, add or replace CharSet named parameter
                    var argumentValue  = CreateCharSetArgument(syntaxFactoryService, charSetType).WithAdditionalAnnotations(Formatter.Annotation);
                    var namedParameter = arguments.FirstOrDefault(arg => arg.NameEquals != null && arg.NameEquals.Name.Identifier.Text == CharSetText);
                    if (namedParameter == null)
                    {
                        // add the parameter
                        namedParameter = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(CharSetText), null, (ExpressionSyntax)argumentValue)
                                         .WithAdditionalAnnotations(Formatter.Annotation);
                        var newArguments    = arguments.Add(namedParameter);
                        var newArgumentList = attribute.ArgumentList.WithArguments(newArguments);
                        newRoot = root.ReplaceNode(attribute.ArgumentList, newArgumentList);
                    }
                    else
                    {
                        // replace the parameter
                        var newNamedParameter = namedParameter.WithExpression((ExpressionSyntax)argumentValue);
                        newRoot = root.ReplaceNode(namedParameter, newNamedParameter);
                    }
                }
                else if (marshalAsType.Equals(attributeType.ContainingType) && arguments.Count == 1)
                {
                    // [MarshalAs] attribute, replace the only argument
                    var newExpression = CreateMarshalAsArgument(syntaxFactoryService, unmanagedType)
                                        .WithLeadingTrivia(arguments[0].GetLeadingTrivia())
                                        .WithTrailingTrivia(arguments[0].GetTrailingTrivia());
                    var newArgument = arguments[0].WithExpression((ExpressionSyntax)newExpression);
                    newRoot = root.ReplaceNode(arguments[0], newArgument);
                }
            }

            return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
        }