private static BaseListSyntax GetBaseTypes(TypeDeclarationSyntax typeNode) { var currentBaseList = typeNode.BaseList; var list = new SeparatedSyntaxList <BaseTypeSyntax>(); foreach (var baseTypeNode in typeNode.BaseList.DescendantNodes(_ => true).OfType <SimpleBaseTypeSyntax>()) { var baseTypeNodeIdentifier = baseTypeNode.DescendantNodes().OfType <IdentifierNameSyntax>().Single(); if (baseTypeNodeIdentifier.Identifier.ValueText == "BusinessRule") { list = list.Add(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("BusinessRuleAsync")) .WithTriviaFrom(baseTypeNode)); } else if (baseTypeNodeIdentifier.Identifier.ValueText == "IBusinessRule") { list = list.Add(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("IBusinessRuleAsync")) .WithTriviaFrom(baseTypeNode)); } else { list = list.Add(baseTypeNode); } } return(SyntaxFactory.BaseList(list).WithTriviaFrom(currentBaseList)); }
private MethodDeclarationSyntax GenerateSignature(MethodDeclarationSyntax method) { var newMethod = method.WithIdentifier( SyntaxFactory.Identifier($"{Settings.AutoPrefix}{method.Identifier.ValueText}")); var parameters = new SeparatedSyntaxList <ParameterSyntax>(); foreach (var parameter in method.ParameterList.Parameters) { if (!parameter.Type.IsKind(SyntaxKind.PredefinedType)) { parameters = parameters.Add(parameter); } else { var autoParam = parameter.WithType(SyntaxFactory.IdentifierName("AutoTFOutput")); parameters = parameters.Add(autoParam); } } var sessionParameter = SyntaxFactory.Parameter(new SyntaxList <AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.IdentifierName("TensorFlow.TFSession"), SyntaxFactory.Identifier("session"), null); parameters = parameters.Add(sessionParameter); newMethod = newMethod.WithParameterList(SyntaxFactory.ParameterList(parameters)); newMethod = newMethod.WithReturnType(SyntaxFactory.IdentifierName("AutoTFOutput")); return(newMethod); }
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); }
public override SyntaxNode VisitInitializerExpression(InitializerExpressionSyntax node) { TypeSyntax typeToCast = null; var rankCount = 0; if (node.Parent is ArrayCreationExpressionSyntax array) { typeToCast = array.Type.ElementType; rankCount = array.Type.RankSpecifiers.Count - 1; } else if (node.IsKind(SyntaxKind.CollectionInitializerExpression) && node.Parent is ObjectCreationExpressionSyntax obj) // e.g. List<int> { document.Field } { var name = obj.Type as GenericNameSyntax; if (name == null && obj.Type is QualifiedNameSyntax qualifiedName) { name = qualifiedName.Right as GenericNameSyntax; } if (name != null) { var arguments = name.TypeArgumentList.Arguments; if (arguments.Count == 1) { typeToCast = arguments[0]; } } } if (typeToCast != null) { var castedExpression = new SeparatedSyntaxList <ExpressionSyntax>(); foreach (var expression in node.Expressions) { if (expression is InitializerExpressionSyntax initializerExpression) // e.g. List<int> { document.Field } { var expressions = initializerExpression.Expressions; if (expressions.Count == 1) { var innerExpression = expressions[0]; expressions = expressions.Replace(innerExpression, CastExpression(typeToCast, rankCount, innerExpression)); initializerExpression = initializerExpression.WithExpressions(expressions); } castedExpression = castedExpression.Add(initializerExpression); continue; } castedExpression = castedExpression.Add(CastExpression(typeToCast, rankCount, expression)); } return(node.WithExpressions(castedExpression)); } return(node); }
private async Task <Document> FixStringFormatAsync(Document document, InvocationExpressionSyntax invocationExpr, CancellationToken cancellationToken) { //This code is largely the same as that in the analyzer, except we already know we have //all the required elements because our analyzer was triggered, and so we can remove //all the conditional logic. var semanticModel = await document.GetSemanticModelAsync(cancellationToken); var memberAccessExpr = invocationExpr.Expression as MemberAccessExpressionSyntax; var memberSymbol = semanticModel.GetSymbolInfo(memberAccessExpr).Symbol as IMethodSymbol; var argumentList = invocationExpr.ArgumentList as ArgumentListSyntax; var patternLiteral = argumentList.Arguments[0].Expression as LiteralExpressionSyntax; var patternOpt = semanticModel.GetConstantValue(patternLiteral); var pattern = patternOpt.Value as string; int maxValue = CSharpQualAnalyzer.GetMaxValueInStringPattern(pattern); //If the pattern in the String.Format statement has no tokens to replace we do not present an error if (maxValue > 0) { //Add the pattern value back to the list of arguments SeparatedSyntaxList <ArgumentSyntax> args = new SeparatedSyntaxList <ArgumentSyntax>(); args = args.Add(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(pattern)))); //Repopulate the arguments, and add empty strings for any additional replacment tokens in the pattern for (int i = 1; i < maxValue + 2; i++) { if (i < argumentList.Arguments.Count) { var argLiteral = argumentList.Arguments[i].Expression as LiteralExpressionSyntax; var argOpt = semanticModel.GetConstantValue(argLiteral); var arg = argOpt.Value as string; args = args.Add(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(arg)))); } else { args = args.Add(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal("")))); } } //Create a new immutable document by instantiating a new one with the new argument list ArgumentListSyntax newArgumentListSyntax = argumentList.WithArguments(args); var root = await document.GetSyntaxRootAsync(); var newRoot = root.ReplaceNode(argumentList, newArgumentListSyntax); var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); } return(document); }
InvocationExpressionSyntax GenerateWlMessage(WaylandProtocolMessage msg) { var signature = new StringBuilder(); if (msg.Since != 0) { signature.Append(msg.Since); } var ifaceList = new SeparatedSyntaxList <ExpressionSyntax>(); if (msg.Arguments != null) { foreach (var arg in msg.Arguments) { if (arg.AllowNull) { signature.Append('?'); } if (arg.Type == WaylandArgumentTypes.NewId && arg.Interface == null) { signature.Append("su"); } signature.Append(WaylandArgumentTypes.NamesToCodes[arg.Type]); if (!string.IsNullOrWhiteSpace(arg.Interface)) { ifaceList = ifaceList.Add( GetWlInterfaceAddressFor(arg.Interface)); } else { ifaceList = ifaceList.Add(MakeNullLiteralExpression()); } } } var argList = ArgumentList(SeparatedList(new[] { Argument(MakeLiteralExpression(msg.Name)), Argument(MakeLiteralExpression(signature.ToString())), Argument(ArrayCreationExpression(ArrayType(ParseTypeName("WlInterface*[]"))) .WithInitializer(InitializerExpression(SyntaxKind.ArrayInitializerExpression, ifaceList))) })); return(InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName("WlMessage"), IdentifierName("Create")), argList ).WithLeadingTrivia(SyntaxFactory.CarriageReturn)); }
public static string ObjectCreationExpression(ObjectCreationExpressionSyntax node) { //Name all the parameters //Thanks! http://stackoverflow.com/questions/24174602/get-constructor-declaration-from-objectcreationexpressionsyntax-with-roslyn/24191494#24191494 var symbol = model.GetSymbolInfo(node).Symbol as IMethodSymbol; var newArgumentListArguments = new SeparatedSyntaxList <ArgumentSyntax>(); for (int i = 0; i < node.ArgumentList.Arguments.Count; i++) { var oldArgumentSyntax = node.ArgumentList.Arguments[i]; var parameterName = symbol.Parameters[i].Name; var identifierSyntax = SyntaxFactory.IdentifierName(parameterName); var nameColonSyntax = SyntaxFactory .NameColon(identifierSyntax) .WithTrailingTrivia(SyntaxFactory.Whitespace(" ")); var newArgumentSyntax = SyntaxFactory.Argument( nameColonSyntax, oldArgumentSyntax.RefOrOutKeyword, oldArgumentSyntax.Expression); newArgumentListArguments = newArgumentListArguments.Add(newArgumentSyntax); } //NOTE: this takes out node.parent and everything, and probably screws with syntaxmodel stuff too var argList = SyntaxFactory.ArgumentList(newArgumentListArguments); var newNode = SyntaxFactory.ObjectCreationExpression(node.NewKeyword, node.Type, argList, node.Initializer); var output = SyntaxNode(node.Type) + SyntaxNode(newNode.ArgumentList); return(output); }
protected PropertySyntax CreateApplicationAreaProperty(SyntaxNode node) { //calculate indent int indentLength = 4; string indent; SyntaxTriviaList leadingTrivia = node.GetLeadingTrivia(); if (leadingTrivia != null) { indent = leadingTrivia.ToString(); int newLinePos = indent.LastIndexOf("/n"); if (newLinePos >= 0) { indent = indent.Substring(newLinePos + 1); } indentLength += indent.Length; } indent = "".PadLeft(indentLength); SyntaxTriviaList leadingTriviaList = SyntaxFactory.ParseLeadingTrivia(indent, 0); SyntaxTriviaList trailingTriviaList = SyntaxFactory.ParseTrailingTrivia("\r\n", 0); SeparatedSyntaxList <IdentifierNameSyntax> values = new SeparatedSyntaxList <IdentifierNameSyntax>(); values = values.Add(SyntaxFactory.IdentifierName(this.ApplicationAreaName)); return(SyntaxFactory.Property(PropertyKind.ApplicationArea, SyntaxFactory.CommaSeparatedPropertyValue(values)) .WithLeadingTrivia(leadingTriviaList) .WithTrailingTrivia(trailingTriviaList)); }
public static IEnumerable <MemberDeclarationSyntax> RemoveFields(this ClassDeclarationSyntax source, IEnumerable <VariableDeclaratorSyntax> variables) { List <MemberDeclarationSyntax> result = new List <MemberDeclarationSyntax>(); foreach (var member in source.Members) { if (!(member is FieldDeclarationSyntax field)) { result.Add(member); continue; } SeparatedSyntaxList <VariableDeclaratorSyntax> newVariables = new SeparatedSyntaxList <VariableDeclaratorSyntax>(); foreach (var variable in field.Declaration.Variables) { if (!variables.Any(c => c.Identifier.ValueText == variable.Identifier.ValueText)) { newVariables.Add(variable); } } if (newVariables.Count == 0) { continue; } result.Add(field.WithDeclaration(field.Declaration.WithVariables(newVariables))); } return(result); }
public static string ObjectCreationExpression(ObjectCreationExpressionSyntax expression) { //Name all the arguments, since Swift usually requires named arguments when you create new objects. //Thanks! http://stackoverflow.com/questions/24174602/get-constructor-declaration-from-objectcreationexpressionsyntax-with-roslyn/24191494#24191494 var symbol = Model.GetSymbolInfo(expression).Symbol as IMethodSymbol; var namedArgumentsList = new SeparatedSyntaxList <ArgumentSyntax>(); for (var i = 0; i < expression.ArgumentList.Arguments.Count; i++) { var oldArgumentSyntax = expression.ArgumentList.Arguments[i]; var parameterName = symbol.Parameters[i].Name; var nameColonSyntax = SyntaxFactory .NameColon(SyntaxFactory.IdentifierName(parameterName)) .WithTrailingTrivia(SyntaxFactory.Whitespace(" ")); var namedArgumentSyntax = SyntaxFactory.Argument(nameColonSyntax, oldArgumentSyntax.RefOrOutKeyword, oldArgumentSyntax.Expression); namedArgumentsList = namedArgumentsList.Add(namedArgumentSyntax); } //NOTE: this takes out expression.parent and everything, and probably screws with SyntaxModel stuff to return(SyntaxNode(expression.Type) + SyntaxNode(SyntaxFactory.ArgumentList(namedArgumentsList))); }
public override SyntaxNode VisitArgumentList(ArgumentListSyntax node) { //注意:相关Query.XXXJoin(join, (u, j1) => u.ID == j1.OtherID)不处理,因本身需要之前的参数 if (queryMethodCtx.HasAny && !queryMethodCtx.Current.HoldLambdaArgs && !queryMethodCtx.Current.InLambdaExpression) { var args = new SeparatedSyntaxList <ArgumentSyntax>(); //eg: q.Where(join1, (u, j1) => u.ID == j1.OtherID) //注意:只处理最后一个参数,即移除之前的参数,如上示例中的join1参数,最后的Lambda由VisitQueryMethodLambdaExpresssion处理 var newArgNode = node.Arguments[node.Arguments.Count - 1].Expression.Accept(this); //eg: q.ToList(join1, (t, j1) => new {t.ID, t.Name, j1.Address}) //需要处理 new {XX,XX,XX}为参数列表 if ((queryMethodCtx.Current.MethodName == TypeHelper.SqlQueryToScalarMethod || queryMethodCtx.Current.MethodName == TypeHelper.SqlQueryToListMethod || queryMethodCtx.Current.MethodName == TypeHelper.SqlUpdateOutputMethod) && newArgNode is ArgumentListSyntax argList) { //已被VisitQueryMethodLambdaExpresssion转换为ArgumentListSyntax args = args.AddRange(argList.Arguments); } else { args = args.Add(SyntaxFactory.Argument((ExpressionSyntax)newArgNode)); } return(SyntaxFactory.ArgumentList(args)); } return(base.VisitArgumentList(node)); }
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); }
static ExpressionSyntax BuildHasFlagExpression(ExpressionSyntax target, ExpressionSyntax expr) { var bOp = expr as BinaryExpressionSyntax; if (bOp != null) { if (bOp.IsKind(SyntaxKind.BitwiseOrExpression)) { return(SyntaxFactory.BinaryExpression( SyntaxKind.BitwiseOrExpression, BuildHasFlagExpression(target, bOp.Left), BuildHasFlagExpression(target, bOp.Right) )); } } var arguments = new SeparatedSyntaxList <ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(MakeFlatExpression(expr, SyntaxKind.BitwiseOrExpression))); return(SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, target, SyntaxFactory.IdentifierName("HasFlag")), SyntaxFactory.ArgumentList(arguments) )); }
public Func <SyntaxGenerator, ClassDeclarationSyntax, ClassDeclarationSyntax> GetRemoveBaseClassAction(string baseClass) { ClassDeclarationSyntax RemoveBaseClass(SyntaxGenerator syntaxGenerator, ClassDeclarationSyntax node) { SeparatedSyntaxList <BaseTypeSyntax> currentBaseTypes = node.BaseList.Types; SeparatedSyntaxList <BaseTypeSyntax> newBaseTypes = new SeparatedSyntaxList <BaseTypeSyntax>(); foreach (var baseTypeSyntax in currentBaseTypes) { if (!baseTypeSyntax.GetText().ToString().Trim().Equals(baseClass)) { newBaseTypes.Add(baseTypeSyntax); } } if (!newBaseTypes.Any()) { node = node.WithBaseList(null); } else { node = node.WithBaseList(node.BaseList.WithTypes(newBaseTypes)); } return(node); } return(RemoveBaseClass); }
public AttributeSyntax GenerateAttribute(string attributeName, object attributeValue, Dictionary <string, object> attributeValues) { var valueNodes = new SeparatedSyntaxList <AttributeArgumentSyntax>(); valueNodes.Add(SyntaxFactory.AttributeArgument(CreateExpressionSyntax(attributeValue))); foreach (var entry in attributeValues) { valueNodes.Add( SyntaxFactory.AttributeArgument(CreateExpressionSyntax(entry.Value)) .WithNameEquals(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(entry.Key)))); } return(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName(attributeName)) .WithArgumentList(SyntaxFactory.AttributeArgumentList(valueNodes))); }
static CodeAction AddIsNaNIssue(Document document, SemanticModel semanticModel, SyntaxNode root, BinaryExpressionSyntax node, ExpressionSyntax argExpr, string floatType) { return(CodeActionFactory.Create(node.Span, DiagnosticSeverity.Warning, string.Format(node.IsKind(SyntaxKind.EqualsExpression) ? "Replace with '{0}.IsNaN(...)' call" : "Replace with '!{0}.IsNaN(...)' call", floatType), token => { SyntaxNode newRoot; ExpressionSyntax expr; var arguments = new SeparatedSyntaxList <ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(argExpr)); expr = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression(floatType), SyntaxFactory.IdentifierName("IsNaN") ), SyntaxFactory.ArgumentList( arguments ) ); if (node.IsKind(SyntaxKind.NotEqualsExpression)) { expr = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, expr); } expr = expr.WithAdditionalAnnotations(Formatter.Annotation); newRoot = root.ReplaceNode((SyntaxNode)node, expr); return Task.FromResult(document.WithSyntaxRoot(newRoot)); })); }
static CodeAction AddCompareIssue(Document document, SemanticModel semanticModel, SyntaxNode root, BinaryExpressionSyntax node, string floatType) { return(CodeActionFactory.Create(node.Span, DiagnosticSeverity.Warning, "Fix floating point number comparison", token => { SyntaxNode newRoot; ExpressionSyntax expr; var arguments = new SeparatedSyntaxList <ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, node.Left, node.Right))); expr = SyntaxFactory.BinaryExpression( node.IsKind(SyntaxKind.EqualsExpression) ? SyntaxKind.LessThanExpression : SyntaxKind.GreaterThanExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression("System.Math"), SyntaxFactory.IdentifierName("Abs") ), SyntaxFactory.ArgumentList( arguments ) ), SyntaxFactory.IdentifierName("EPSILON") ); expr = expr.WithAdditionalAnnotations(Formatter.Annotation); newRoot = root.ReplaceNode((SyntaxNode)node, expr); return Task.FromResult(document.WithSyntaxRoot(newRoot)); })); }
public override SyntaxNode VisitObjectCreationExpression( ObjectCreationExpressionSyntax node) { var baseResult = (ObjectCreationExpressionSyntax) base.VisitObjectCreationExpression(node); var ctorSymbol = _semanticModel.GetSymbolInfo(node).Symbol as IMethodSymbol; if (ctorSymbol == null) { return(baseResult); } var newArgumentListArguments = new SeparatedSyntaxList <ArgumentSyntax>(); for (int i = 0; i < baseResult.ArgumentList.Arguments.Count; i++) { var oldArgumentSyntax = baseResult.ArgumentList.Arguments[i]; var parameterName = ctorSymbol.Parameters[i].Name; var identifierSyntax = SyntaxFactory.IdentifierName(parameterName); var nameColonSyntax = SyntaxFactory .NameColon(identifierSyntax) .WithTrailingTrivia(SyntaxFactory.Whitespace(" ")); var newArgumentSyntax = SyntaxFactory.Argument( nameColonSyntax, oldArgumentSyntax.RefOrOutKeyword, oldArgumentSyntax.Expression); newArgumentListArguments = newArgumentListArguments.Add(newArgumentSyntax); } return(baseResult .WithArgumentList(baseResult.ArgumentList .WithArguments(newArgumentListArguments))); }
public static ArrowExpressionClauseSyntax GenerateSpanNameValues(MemberDeclarationMeta memberdecl) //=> { byte, byte, byte, byte} { SeparatedSyntaxList <ExpressionSyntax> ArrayInitExpr(MemberDeclarationMeta memberdecl) { SeparatedSyntaxList <ExpressionSyntax> expr = new SeparatedSyntaxList <ExpressionSyntax>(); foreach (var byteItem in Encoding.UTF8.GetBytes(memberdecl.StringFieldNameAlias)) { expr = expr.Add(Basics.NumberLiteral(byteItem)); } return(expr); } ArrayRankSpecifierSyntax ArrayRank(MemberDeclarationMeta memberdecl) { return(SF.ArrayRankSpecifier().AddSizes(Basics.NumberLiteral(memberdecl.StringFieldNameAlias.Length))); } return(SF.ArrowExpressionClause( SF.ArrayCreationExpression( SF.ArrayType( SF.PredefinedType(SF.Token(SyntaxKind.ByteKeyword)), SF.SingletonList <ArrayRankSpecifierSyntax>(ArrayRank(memberdecl))), SF.InitializerExpression(SyntaxKind.ArrayInitializerExpression, ArrayInitExpr(memberdecl)) ) )); }
private ArgumentListSyntax DecomposeEqualsFunction(ArgumentListSyntax argumentList, out bool isNotEquals) { ArgumentSyntax first = argumentList.Arguments[0]; List <ArgumentSyntax> rest = argumentList.Arguments.Skip(1).ToList(); ExtractEqualsFunction(first, out ArgumentSyntax areEqualsExpected, out ArgumentSyntax areEqualsActual, out isNotEquals); SeparatedSyntaxList <ArgumentSyntax> newArguments = new SeparatedSyntaxList <ArgumentSyntax>(); newArguments = newArguments.Add(areEqualsExpected); newArguments = newArguments.Add(areEqualsActual); newArguments = newArguments.AddRange(rest); return(SyntaxFactory.ArgumentList(newArguments)); }
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 ParameterListSyntax CreateParameterList(SemanticModel semanticModel, IMethodSymbol methodSymbol, MethodDeclarationSyntax methodDeclarationSyntax) { var parameterList = methodDeclarationSyntax.ParameterList; var newParameters = new SeparatedSyntaxList <ParameterSyntax>(); for (var index = 0; index < parameterList.Parameters.Count; index++) { var originalParameter = parameterList.Parameters[index]; var newParameter = originalParameter; var targetTypeSymbol = methodSymbol.Parameters[index]; var sourceTypeSymbol = semanticModel.GetSymbolInfo(originalParameter.Type).Symbol; if (sourceTypeSymbol == null) { goto add; } if (sourceTypeSymbol.Equals(targetTypeSymbol)) { goto add; } newParameter = originalParameter.WithType(IdentifierName(targetTypeSymbol.Type.MetadataName)); add: newParameters = newParameters.Add(newParameter); } return(parameterList.WithParameters(newParameters)); }
public ExpressionStatementSyntax Visit(ExpressionStatementSyntax expressionStatement) { if (!(expressionStatement.Expression is InvocationExpressionSyntax ignorExpression)) { return(expressionStatement); } if (!(ignorExpression.Expression is MemberAccessExpressionSyntax ignoreMember)) { return(expressionStatement); } if (!(ignoreMember.Expression is InvocationExpressionSyntax node)) { return(expressionStatement); } if (!(node.Expression is MemberAccessExpressionSyntax memberOuter)) { return(expressionStatement); } if (!(memberOuter.Expression is InvocationExpressionSyntax nodeInner)) { return(expressionStatement); } if (!(nodeInner.Expression is MemberAccessExpressionSyntax member)) { return(expressionStatement); } if (!(member.Expression is IdentifierNameSyntax identifier)) { return(expressionStatement); } var nodeString = expressionStatement.ToString(); var isExpect = nodeString.Contains(".Expect"); var mockGet = SyntaxFactory.IdentifierName(identifier.Identifier.ValueText + "Mock"); member = member.WithExpression(mockGet).WithName(SyntaxFactory.IdentifierName("SetupIgnoreArgs")); nodeInner = nodeInner.WithExpression(member); memberOuter = memberOuter.WithExpression(nodeInner).WithName(SyntaxFactory.IdentifierName("Returns")); node = node.WithExpression(memberOuter); if (node.ArgumentList?.Arguments == null || node.ArgumentList.Arguments.Count <= 0) { return(expressionStatement.WithExpression(node)); } var argumentList = new SeparatedSyntaxList <ArgumentSyntax>(); foreach (var argument in node.ArgumentList.Arguments) { if (argument.Expression is LiteralExpressionSyntax literal && literal.Kind() == SyntaxKind.NullLiteralExpression) { argumentList = argumentList.Add( argument.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName("value")))); }
public static ArrayCreationExpressionSyntax CreateArrayOf(string typeName, ExpressionSyntax[] expressions, int ranksAmount = 1) { var newKeyword = SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.NewKeyword, SyntaxTriviaList.Create(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, " "))); var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>(); for (var i = 0; i < expressions.Length; i++) { syntaxList = syntaxList.Add(expressions[i]); } var rankSpecifiers = new SyntaxList <ArrayRankSpecifierSyntax>(); for (var i = 0; i < ranksAmount; i++) { rankSpecifiers = rankSpecifiers.Add( SyntaxFactory.ArrayRankSpecifier( SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList <ExpressionSyntax> { SyntaxFactory.OmittedArraySizeExpression( SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken) ) }, SyntaxFactory.Token(SyntaxKind.CloseBracketToken) ) ); } return(SyntaxFactory.ArrayCreationExpression( newKeyword, SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName(typeName), rankSpecifiers), SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, syntaxList))); }
private static ArgumentListSyntax BuildArgumentList( ExpressionSyntax expression, SeparatedSyntaxList <ArgumentSyntax>?additionalArguments) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } ArgumentListSyntax argumentList; if (additionalArguments.HasValue && additionalArguments.Value.Any()) { var args = new SeparatedSyntaxList <ArgumentSyntax>(); args = args.Add(SyntaxFactory.Argument(expression)); args = args.AddRange(additionalArguments.Value); argumentList = SyntaxFactory.ArgumentList(args); } else { argumentList = SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument(expression))); } return(argumentList); }
public static ArgumentListSyntax TransformParentInvocationArguments( this MemberAccessExpressionSyntax memberAccess, ExceptionSyntaxDetails details, int numArgumentsRequired, Func <ArgumentSyntax, int, ArgumentSyntax> transform ) { if (details == null) { throw new ArgumentNullException(nameof(details)); } if (transform == null) { throw new ArgumentNullException(nameof(transform)); } if (memberAccess?.Parent is InvocationExpressionSyntax invocation && invocation.ArgumentList?.Arguments.Count == numArgumentsRequired) { var result = new SeparatedSyntaxList <ArgumentSyntax>(); for (int i = 0; i < invocation.ArgumentList.Arguments.Count; i++) { var transformed = transform(invocation.ArgumentList.Arguments[i], i); if (transformed == null) { details.SetInconclusive(invocation.ArgumentList.Arguments[i]?.ToString()); return(null); } result = result.Add(transformed); } return(SyntaxFactory.ArgumentList(result)); } details.SetInconclusive(memberAccess?.ToString()); return(null); }
private ArgumentListSyntax DecomposeEqualsEquals(SyntaxKind kind, ArgumentListSyntax argumentList, out bool isNotEquals, out bool isNullArgument) { ArgumentSyntax first = argumentList.Arguments[0]; List <ArgumentSyntax> rest = argumentList.Arguments.Skip(1).ToList(); switch (kind) { case SyntaxKind.EqualsExpression: isNotEquals = false; break; case SyntaxKind.NotEqualsExpression: isNotEquals = true; break; default: throw new ArgumentException("kind is not supported", nameof(kind)); } ExtractEqualsEquals(first, out ArgumentSyntax areEqualsExpected, out ArgumentSyntax areEqualsActual); SeparatedSyntaxList <ArgumentSyntax> newArguments = new SeparatedSyntaxList <ArgumentSyntax>(); if (areEqualsActual.Expression.Kind() == SyntaxKind.NullLiteralExpression) { isNullArgument = true; newArguments = newArguments.Add(areEqualsExpected); } else if (areEqualsExpected.Expression.Kind() == SyntaxKind.NullLiteralExpression) { isNullArgument = true; newArguments = newArguments.Add(areEqualsActual); } else { isNullArgument = false; newArguments = newArguments.Add(areEqualsExpected); newArguments = newArguments.Add(areEqualsActual); } newArguments = newArguments.AddRange(rest); return(SyntaxFactory.ArgumentList(newArguments)); }
public static AttributeListSyntax BuildAttributeList(AttributeSyntax attribute) { var attributeList = new SeparatedSyntaxList <AttributeSyntax>(); attributeList = attributeList.Add(attribute); return(SyntaxFactory.AttributeList(attributeList)); }
public static SeparatedSyntaxList <T> AddIfNotNull <T>(this SeparatedSyntaxList <T> list, T?argument) where T : SyntaxNode { if (argument != null) { return(list.Add(argument)); } return(list); }
private async Task <Document> AddDateMemberAttributesAndFixOrder(Document document, PropertyDeclarationSyntax[] publicProperties, PropertyDeclarationSyntax[] propertiesWithDataMemberAttributeWithoutOrder, PropertyDeclarationSyntax[] propertiesWithDataMemberAttributeWithOrder, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(cancellationToken); int max = 0; if (propertiesWithDataMemberAttributeWithOrder.Any()) { max = propertiesWithDataMemberAttributeWithOrder.Max(p => GetOrder(GetDataMemberAttribute(p)) ?? 0); } var updateNodes = new Dictionary <SyntaxNode, SyntaxNode>(); foreach (var property in propertiesWithDataMemberAttributeWithoutOrder) { var attribute = GetDataMemberAttribute(property); //DataMember AttributeArgumentListSyntax arguments = CreateOrderArgument(++max); var args = attribute.ArgumentList?.Arguments.ToArray(); AttributeArgumentListSyntax allArgs = arguments; if (args != null) { allArgs = arguments.AddArguments(args); } var newAttribute = attribute.WithArgumentList(allArgs); //DataMember(Order = #) updateNodes.Add(attribute, newAttribute); } foreach (var property in publicProperties.Except(propertiesWithDataMemberAttributeWithoutOrder.Union(propertiesWithDataMemberAttributeWithOrder))) { var name = SyntaxFactory.ParseName(DataMember); AttributeArgumentListSyntax arguments = CreateOrderArgument(++max); var attribute = SyntaxFactory.Attribute(name, arguments); //DataMember(Order = #) var attributeList = new SeparatedSyntaxList <AttributeSyntax>(); attributeList = attributeList.Add(attribute); var list = SyntaxFactory.AttributeList(attributeList); //[DataMember(Order = #)] var modifier = property.Modifiers.FirstOrDefault(); if (modifier != null) { var commentsT = modifier.LeadingTrivia; list = list.WithLeadingTrivia(commentsT); } var newModifiers = SyntaxFactory.TokenList(property.Modifiers.Skip(1).Concat(new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword) }));; var newProperty = property.AddAttributeLists(list).WithModifiers(newModifiers); updateNodes.Add(property, newProperty); } root = root.ReplaceNodes(updateNodes.Keys, (n1, n2) => { return(updateNodes[n1]); }); return(document.WithSyntaxRoot(root)); }
public override SyntaxNode VisitClassDeclaration(ClassDeclarationSyntax node) { node = (ClassDeclarationSyntax)base.VisitClassDeclaration(node); SyntaxList<MemberDeclarationSyntax> newMembers = new SyntaxList<MemberDeclarationSyntax>(); foreach (MemberDeclarationSyntax member in node.Members) { if (member.Kind == SyntaxKind.PropertyDeclaration) { PropertyDeclarationSyntax prop = (PropertyDeclarationSyntax)member; SyntaxList<AccessorDeclarationSyntax> newAccessors = new SyntaxList<AccessorDeclarationSyntax>(); bool implementfield = false; foreach (AccessorDeclarationSyntax accessor in prop.AccessorList.Accessors) { if (accessor.Body == null) { switch (accessor.Kind) { case SyntaxKind.GetAccessorDeclaration: implementfield = true; newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ReturnStatement(Syntax.IdentifierName("_" + prop.Identifier.ValueText))))); break; case SyntaxKind.SetAccessorDeclaration: implementfield = true; newAccessors = newAccessors.Add(accessor.WithBody(Syntax.Block(Syntax.ExpressionStatement(Syntax.BinaryExpression(SyntaxKind.AssignExpression, Syntax.IdentifierName("_" + prop.Identifier.ValueText), Syntax.IdentifierName("value")))))); break; default: newAccessors = newAccessors.Add(accessor); break; } } else { newAccessors = newAccessors.Add(accessor); } } if (implementfield) { SeparatedSyntaxList<VariableDeclaratorSyntax> variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>(); variables = variables.Add(Syntax.VariableDeclarator("_" + prop.Identifier.ValueText)); newMembers = newMembers.Add(Syntax.FieldDeclaration(Syntax.VariableDeclaration(prop.Type, variables))); } newMembers = newMembers.Add(prop.WithAccessorList(prop.AccessorList.WithAccessors(newAccessors))); } else { newMembers = newMembers.Add(member); } } return node.WithMembers(newMembers); }
// TODO : not sure if this makes sense // Test and enable or add comment with reason //public override FixAllProvider GetFixAllProvider() //{ // return WellKnownFixAllProviders.BatchFixer; //} public async override Task RegisterCodeFixesAsync(CodeFixContext context) { var document = context.Document; var cancellationToken = context.CancellationToken; var span = context.Span; var diagnostics = context.Diagnostics; var root = await document.GetSyntaxRootAsync(cancellationToken); var diagnostic = diagnostics.First(); var node = root.FindNode(context.Span) as InvocationExpressionSyntax; if (node == null) return; context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Change invocation to call 'object.ReferenceEquals'", arg => { var arguments = new SeparatedSyntaxList<ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(SyntaxFactory.ThisExpression())); arguments = arguments.Add(node.ArgumentList.Arguments[0]); return Task.FromResult(document.WithSyntaxRoot( root.ReplaceNode((SyntaxNode) node, SyntaxFactory.InvocationExpression( SyntaxFactory.ParseExpression("object.ReferenceEquals"), SyntaxFactory.ArgumentList(arguments) ) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)) ) ); }), diagnostic); context.RegisterCodeFix(CodeActionFactory.Create(node.Span, diagnostic.Severity, "Remove 'base.'", arg => { return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode((SyntaxNode)node, node.WithExpression(SyntaxFactory.IdentifierName("Equals"))))); }), diagnostic); }
public override SyntaxNode VisitElementAccessExpression(ElementAccessExpressionSyntax node) { var elements = GetListCollectionInitializerElements(node); if (elements != null) { if (elements.Count > 0) { var type = GetArgumentType(elements[0]); var syntaxList = new SeparatedSyntaxList<ExpressionSyntax>(); var intializerExpr = Syntax.InitializerExpression(SyntaxKind.CollectionInitializerExpression, syntaxList.Add(elements.ToArray())); return Syntax.ParseExpression(string.Format("new System.Collections.Generic.List<{1}>{0}", intializerExpr, type)); } else { //no elements of list - returning empty list of objects return Syntax.ParseExpression("new System.Collections.Generic.List<Object>()"); } } return base.VisitElementAccessExpression(node); }
static ExpressionSyntax BuildHasFlagExpression(ExpressionSyntax target, ExpressionSyntax expr) { var bOp = expr as BinaryExpressionSyntax; if (bOp != null) { if (bOp.IsKind(SyntaxKind.BitwiseOrExpression)) { return SyntaxFactory.BinaryExpression( SyntaxKind.BitwiseOrExpression, BuildHasFlagExpression(target, bOp.Left), BuildHasFlagExpression(target, bOp.Right) ); } } var arguments = new SeparatedSyntaxList<ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(MakeFlatExpression(expr, SyntaxKind.BitwiseOrExpression))); return SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, target, SyntaxFactory.IdentifierName("HasFlag")), SyntaxFactory.ArgumentList(arguments) ); }
static ITypeSymbol CreateClass (MonoDevelop.Projects.Project project, Stetic.ActionGroupComponent group, string name, string namspace, string folder) { string fullName = namspace.Length > 0 ? namspace + "." + name : name; var type = SyntaxFactory.ClassDeclaration (name) .AddBaseListTypes (SyntaxFactory.SimpleBaseType (SyntaxFactory.ParseTypeName ("Gtk.ActionGroup"))); // Generate the constructor. It contains the call that builds the widget. var members = new SyntaxList<MemberDeclarationSyntax> (); var ctor = SyntaxFactory.ConstructorDeclaration ( new SyntaxList<AttributeListSyntax> (), SyntaxFactory.TokenList (SyntaxFactory.Token (SyntaxKind.PublicKeyword)), SyntaxFactory.Identifier (name), SyntaxFactory.ParameterList (), SyntaxFactory.ConstructorInitializer (SyntaxKind.BaseKeyword, SyntaxFactory.ArgumentList (new SeparatedSyntaxList<ArgumentSyntax> { SyntaxFactory.Argument (SyntaxFactory.ParseExpression (fullName)) } )), SyntaxFactory.Block ( SyntaxFactory.ExpressionStatement ( SyntaxFactory.InvocationExpression ( SyntaxFactory.ParseExpression ("Stetic.Gui.Build"), SyntaxFactory.ArgumentList ( new SeparatedSyntaxList<ArgumentSyntax> { SyntaxFactory.Argument (SyntaxFactory.ThisExpression ()), SyntaxFactory.Argument (SyntaxFactory.ParseExpression (fullName)) } ) ) ) ) ); type = type.AddMembers (ctor); // Add signal handlers foreach (Stetic.ActionComponent action in group.GetActions ()) { foreach (Stetic.Signal signal in action.GetSignals ()) { var parameters = new SeparatedSyntaxList<ParameterSyntax> (); foreach (var p in signal.SignalDescriptor.HandlerParameters) { parameters = parameters.Add (SyntaxFactory.Parameter (new SyntaxList<AttributeListSyntax> (), SyntaxFactory.TokenList (), SyntaxFactory.ParseTypeName (p.TypeName), SyntaxFactory.Identifier (p.Name), null)); } var met = SyntaxFactory.MethodDeclaration ( new SyntaxList<AttributeListSyntax> (), SyntaxFactory.TokenList (SyntaxFactory.Token (SyntaxKind.ProtectedKeyword)), SyntaxFactory.ParseTypeName (signal.SignalDescriptor.HandlerReturnTypeName), null, SyntaxFactory.Identifier (signal.Handler), null, SyntaxFactory.ParameterList (parameters), new SyntaxList<TypeParameterConstraintClauseSyntax> (), SyntaxFactory.Block (), null ); type = type.AddMembers (met); } } // Create the class return CodeGenerationService.AddType ((DotNetProject)project, folder, namspace, type); }
static CodeAction AddIsNaNIssue(Document document, SemanticModel semanticModel, SyntaxNode root, BinaryExpressionSyntax node, ExpressionSyntax argExpr, string floatType) { return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Warning, string.Format(node.IsKind(SyntaxKind.EqualsExpression) ? "Replace with '{0}.IsNaN(...)' call" : "Replace with '!{0}.IsNaN(...)' call", floatType), token => { SyntaxNode newRoot; ExpressionSyntax expr; var arguments = new SeparatedSyntaxList<ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(argExpr)); expr = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression(floatType), SyntaxFactory.IdentifierName("IsNaN") ), SyntaxFactory.ArgumentList( arguments ) ); if (node.IsKind(SyntaxKind.NotEqualsExpression)) expr = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, expr); expr = expr.WithAdditionalAnnotations(Formatter.Annotation); newRoot = root.ReplaceNode((SyntaxNode)node, expr); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }); }
internal static FieldDeclarationSyntax CreateEmptyRule(SyntaxGenerator generator, string idName="Change me to the name of the above constant", string titleDefault="Enter a title for this diagnostic", string messageDefault="Enter a message to be displayed with this diagnostic", string categoryDefault="Enter a category for this diagnostic (e.g. Formatting)", ExpressionSyntax severityDefault=null, ExpressionSyntax enabledDefault=null) { if (severityDefault == null) { severityDefault = generator.DefaultExpression(SyntaxFactory.ParseTypeName("DiagnosticSeverity")) as ExpressionSyntax; } if (enabledDefault == null) { enabledDefault = generator.DefaultExpression(generator.TypeExpression(SpecialType.System_Boolean)) as ExpressionSyntax; } var type = SyntaxFactory.ParseTypeName("DiagnosticDescriptor"); var arguments = new ArgumentSyntax[6]; var whitespace = " "; var id = generator.LiteralExpression(idName); var idArg = generator.Argument("id", RefKind.None, id).WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[0] = idArg; var title = generator.LiteralExpression(titleDefault); var titleArg = generator.Argument("title", RefKind.None, title).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[1] = titleArg; var message = generator.LiteralExpression(messageDefault); var messageArg = generator.Argument("messageFormat", RefKind.None, message).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[2] = messageArg; var category = generator.LiteralExpression(categoryDefault); var categoryArg = generator.Argument("category", RefKind.None, category).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[3] = categoryArg; var defaultSeverityArg = generator.Argument("defaultSeverity", RefKind.None, severityDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[4] = defaultSeverityArg; var enabledArg = generator.Argument("isEnabledByDefault", RefKind.None, enabledDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax; arguments[5] = enabledArg; var identifier = SyntaxFactory.ParseToken("spacingRule"); var separators = new List<SyntaxToken>(); var separator = SyntaxFactory.ParseToken(",").WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed); separators.Add(separator); separators.Add(separator); separators.Add(separator); separators.Add(separator); separators.Add(separator); var argumentsNewLines = SyntaxFactory.SeparatedList(arguments, separators); var argumentList = SyntaxFactory.ArgumentList(argumentsNewLines); var value = SyntaxFactory.ObjectCreationExpression(type, argumentList, null); var initializer = SyntaxFactory.EqualsValueClause(value); var variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>(); var variable = SyntaxFactory.VariableDeclarator(identifier, null, initializer); variables = variables.Add(variable); var declaration = SyntaxFactory.VariableDeclaration(type.WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), variables); var modifiers = SyntaxFactory.TokenList(SyntaxFactory.ParseToken("internal").WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), SyntaxFactory.ParseToken("static").WithTrailingTrivia(SyntaxFactory.Whitespace(" "))); var rule = SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), modifiers, declaration); return rule; }
// creates a correct register statement protected internal static SyntaxNode CreateRegister(SyntaxGenerator generator, MethodDeclarationSyntax declaration, string methodName) { var argument1 = generator.Argument(generator.IdentifierName(methodName)) as ArgumentSyntax; var argument2 = generator.Argument(generator.MemberAccessExpression(generator.IdentifierName("SyntaxKind"), "IfStatement")) as ArgumentSyntax; SeparatedSyntaxList<ArgumentSyntax> arguments = new SeparatedSyntaxList<ArgumentSyntax>(); arguments = arguments.Add(argument1); arguments = arguments.Add(argument2); ArgumentListSyntax argumentList = SyntaxFactory.ArgumentList(arguments); string parameterName = GetFirstParameterName(declaration); SyntaxNode invocationExpr = BuildRegister(generator, parameterName, "RegisterSyntaxNodeAction", argumentList); return invocationExpr; }
private static SyntaxNode SimplifyMethodAndConstructorInvocation(ref int numbering, ref SyntaxList<StatementSyntax> preList, SyntaxNode original, SyntaxNode origWithReplacedDesc) { SeparatedSyntaxList<ArgumentSyntax> slst = new SeparatedSyntaxList<ArgumentSyntax>(); SeparatedSyntaxList<ArgumentSyntax> myArgs; InvocationExpressionSyntax ies = null; ObjectCreationExpressionSyntax oces = null; // es necesario manejarlos por separado, porque pese a que ambos tienen como propiedad Arguments // de tipo SeparatedSyntaxList<ArgumentSyntax>, no estan en la misma linea de jerarquia // de clases... entonces: if (origWithReplacedDesc.IsKind(SyntaxKind.InvocationExpression)) { ies = (InvocationExpressionSyntax)origWithReplacedDesc; myArgs = ies.ArgumentList.Arguments; } else { oces = (ObjectCreationExpressionSyntax)origWithReplacedDesc; myArgs = oces.ArgumentList.Arguments; } foreach (var arg in myArgs) { if (!(arg.Expression is LiteralExpressionSyntax || arg.Expression is IdentifierNameSyntax)) { numbering++; preList = preList.Add(SyntaxFactory.ParseStatement("var __a" + numbering + " = " + arg + ";")); slst = slst.Add((SyntaxFactory.Argument(SyntaxFactory.ParseExpression("__a" + numbering)))); } } if (slst.Count() > 0) { var argumentList = SyntaxFactory.ArgumentList(slst); if (origWithReplacedDesc.IsKind(SyntaxKind.InvocationExpression)) { return ies.WithArgumentList(argumentList); } else { return oces.WithArgumentList(argumentList); } } else return original; }
static CodeAction AddCompareIssue(Document document, SemanticModel semanticModel, SyntaxNode root, BinaryExpressionSyntax node, string floatType) { return CodeActionFactory.Create(node.Span, DiagnosticSeverity.Warning, "Fix floating point number comparison", token => { SyntaxNode newRoot; ExpressionSyntax expr; var arguments = new SeparatedSyntaxList<ArgumentSyntax>(); arguments = arguments.Add(SyntaxFactory.Argument(SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, node.Left, node.Right))); expr = SyntaxFactory.BinaryExpression( node.IsKind(SyntaxKind.EqualsExpression) ? SyntaxKind.LessThanExpression : SyntaxKind.GreaterThanExpression, SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseExpression("System.Math"), SyntaxFactory.IdentifierName("Abs") ), SyntaxFactory.ArgumentList( arguments ) ), SyntaxFactory.IdentifierName("EPSILON") ); expr = expr.WithAdditionalAnnotations(Formatter.Annotation); newRoot = root.ReplaceNode((SyntaxNode)node, expr); return Task.FromResult(document.WithSyntaxRoot(newRoot)); }); }
private void DoTestAddInsertRemoveOnEmptyList(SeparatedSyntaxList<SyntaxNode> list) { Assert.Equal(0, list.Count); SyntaxNode nodeD = SyntaxFactory.ParseExpression("D"); SyntaxNode nodeE = SyntaxFactory.ParseExpression("E"); var newList = list.Add(nodeD); Assert.Equal(1, newList.Count); Assert.Equal("D", newList.ToFullString()); newList = list.AddRange(new[] { nodeD, nodeE }); Assert.Equal(2, newList.Count); Assert.Equal("D,E", newList.ToFullString()); newList = list.Insert(0, nodeD); Assert.Equal(1, newList.Count); Assert.Equal("D", newList.ToFullString()); newList = list.InsertRange(0, new[] { nodeD, nodeE }); Assert.Equal(2, newList.Count); Assert.Equal("D,E", newList.ToFullString()); newList = list.Remove(nodeD); Assert.Equal(0, newList.Count); Assert.Equal(-1, list.IndexOf(nodeD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.RemoveAt(0)); Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(1, nodeD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.Insert(-1, nodeD)); Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(1, new[] { nodeD })); Assert.Throws<ArgumentOutOfRangeException>(() => list.InsertRange(-1, new[] { nodeD })); Assert.Throws<ArgumentNullException>(() => list.Add(null)); Assert.Throws<ArgumentNullException>(() => list.AddRange((IEnumerable<SyntaxNode>)null)); Assert.Throws<ArgumentNullException>(() => list.Insert(0, null)); Assert.Throws<ArgumentNullException>(() => list.InsertRange(0, (IEnumerable<SyntaxNode>)null)); }
public static string ObjectCreationExpression(ObjectCreationExpressionSyntax expression) { //Name all the arguments, since Swift usually requires named arguments when you create new objects. //Thanks! http://stackoverflow.com/questions/24174602/get-constructor-declaration-from-objectcreationexpressionsyntax-with-roslyn/24191494#24191494 var symbol = Model.GetSymbolInfo(expression).Symbol as IMethodSymbol; var namedArgumentsList = new SeparatedSyntaxList<ArgumentSyntax>(); for (var i = 0; i < expression.ArgumentList.Arguments.Count; i++) { var oldArgumentSyntax = expression.ArgumentList.Arguments[i]; var parameterName = symbol.Parameters[i].Name; var nameColonSyntax = SyntaxFactory .NameColon(SyntaxFactory.IdentifierName(parameterName)) .WithTrailingTrivia(SyntaxFactory.Whitespace(" ")); var namedArgumentSyntax = SyntaxFactory.Argument(nameColonSyntax, oldArgumentSyntax.RefOrOutKeyword, oldArgumentSyntax.Expression); namedArgumentsList = namedArgumentsList.Add(namedArgumentSyntax); } //NOTE: this takes out expression.parent and everything, and probably screws with SyntaxModel stuff to return SyntaxNode(expression.Type) + SyntaxNode(SyntaxFactory.ArgumentList(namedArgumentsList)); }
private static NameSyntax ConsumeName(List<SyntaxToken> tokens, bool canBeGlobal = false) { // If we're here, we know the first token is a valid identifier var identifier = tokens.First (); tokens.RemoveAt (0); // The only valid next thing could be open parenthesis + "Of" for generic if (tokens.Count < 2) return Syntax.IdentifierName (identifier); if (tokens.First ().Kind != SyntaxKind.OpenParenToken) return CreateIdentifer (identifier, canBeGlobal); if (tokens.ElementAt (1).Kind != SyntaxKind.OfKeyword) return Syntax.IdentifierName (identifier); var open_param = tokens.First (); tokens.RemoveAt (0); var of_keyword = tokens.First (); tokens.RemoveAt (0); // Parse generic arguments var arguments = new SeparatedSyntaxList<TypeSyntax> (); while (true) { // Get a generic argument type var type = ConsumeQualifiedName (tokens); arguments.Add (type); // No closing parenthesis, return a IsMissing one if (tokens.Count == 0) return Syntax.GenericName (identifier, Syntax.TypeArgumentList (open_param, of_keyword, arguments, Syntax.MissingToken (SyntaxKind.CloseParenToken))); var token = tokens.First (); // We hit a closing parenthesis, return our generic name if (token.Kind == SyntaxKind.CloseParenToken) { tokens.RemoveAt (0); return Syntax.GenericName (identifier, Syntax.TypeArgumentList (open_param, of_keyword, arguments, token)); } // We hit a comma, store it and restart to find the next token if (token.Kind == SyntaxKind.CommaToken) { tokens.RemoveAt (0); arguments.Add (token); } else { // Something else we don't handle, add a missing close parenthesis and return var missing_token = Syntax.MissingToken (SyntaxKind.CloseParenToken); return Syntax.GenericName (identifier, Syntax.TypeArgumentList (open_param, of_keyword, arguments, missing_token)); } } }
private static NameSyntax ConsumeQualifiedName(List<SyntaxToken> tokens) { var list = new SeparatedSyntaxList<NameSyntax> (); var last_was_dot = true; var can_be_global = true; // Get all the name pieces and dot tokens while (true) { var token = tokens.First (); if (token.Kind == SyntaxKind.DotToken) { // Handle a malformed case of starting with a period if (list.Count == 0) { var missing_token = Syntax.MissingToken (SyntaxKind.IdentifierToken); tokens.Insert (0, missing_token); var name = ConsumeName (tokens); list.Add (name); can_be_global = false; } // Remove the dot from tokens and add it to syntax list tokens.RemoveAt (0); list.Add (token); // Implicit continuation after dot while (tokens.Count > 0 && tokens.First ().Kind == SyntaxKind.StatementTerminatorToken) { var term = tokens.First (); tokens.RemoveAt (0); } last_was_dot = true; } else if (IsValidIdentifier (token) && last_was_dot) { // Remove the name from tokens and add it to syntax list var name = ConsumeName (tokens, can_be_global); list.Add (name); last_was_dot = false; can_be_global = false; } else if (token.Kind == SyntaxKind.OpenParenToken && list.Count == 0) { // Handle a malformed case with nothing before the open parenthesis var missing_token = Syntax.MissingToken (SyntaxKind.IdentifierToken); tokens.Insert (0, missing_token); var name = ConsumeName (tokens); list.Add (name); last_was_dot = false; } else { break; } } // No valid name case if (list.Count == 0) { var missing_token = Syntax.MissingToken (SyntaxKind.IdentifierToken); tokens.Insert (0, missing_token); list.Add (ConsumeName (tokens)); } // Trails with a period and no valid identifier after if (list.Count == list.SeparatorCount) { var missing_token = Syntax.MissingToken (SyntaxKind.IdentifierToken); tokens.Insert (0, missing_token); list.Add (ConsumeName (tokens)); } // Build them into a QualifiedNameSyntax return BuildQualifiedSyntax (list); }