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