private static void ExpandSnippet(ArgumentSyntax arg1, ArgumentSyntax arg2, ref SyntaxNodeOrToken[] right, ref int count)
{
if (int.Parse(arg1.ToString()) < int.Parse(arg2.ToString()))
{
right = new SyntaxNodeOrToken[(int.Parse(arg2.ToString()) - int.Parse(arg1.ToString()) + 1) * 2 - 1];
for (int i = int.Parse(arg1.ToString()); i <= int.Parse(arg2.ToString()); i++)
{
var val = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(i));
right[count] = val;
count++;
if (i < int.Parse(arg2.ToString()))
{
right[count] = SyntaxFactory.Token(SyntaxKind.CommaToken);
count++;
}
}
}
else if (int.Parse(arg1.ToString()) > int.Parse(arg2.ToString()))
{
right = new SyntaxNodeOrToken[(int.Parse(arg1.ToString()) - int.Parse(arg2.ToString()) + 1) * 2 - 1];
for (int i = int.Parse(arg1.ToString()); i >= int.Parse(arg2.ToString()); i--)
{
var val = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(i));
right[count] = val;
count++;
if (i > int.Parse(arg2.ToString()))
{
right[count] = SyntaxFactory.Token(SyntaxKind.CommaToken);
count++;
}
}
}
for (int i = 0; i < count; i++)
{
Console.Write(right[i]);
}
Console.WriteLine();
Console.WriteLine();
}
public override Evaluation VisitArgument(ArgumentSyntax node)
{
Frame frame = _callStack.Peek();
IEnumerable <Instance> found = frame.ContainingHeap.FindInstance(node.GetReference(), _comp);
node.NameColon?.Accept <Evaluation>(this);
node.Expression?.Accept <Evaluation>(this);
int count = found.Count();
if (count > 1)
{
Log.Warn("More then one instance found for argument: {0}", node.ToString());
}
else if (count == 0)
{
Log.Error("Argument instance not found for node {0}", node.ToString());
}
return(found.FirstOrDefault());
}
private void AnalyzeSuffix(ArgumentSyntax argument, SemanticModel semanticModel, ICollection <Diagnostic> list)
{
var argumentName = argument.ToString();
if (argumentName.EndsWith(Suffix, StringComparison.Ordinal))
{
var location = argument.GetLocation();
var symbol = semanticModel.LookupSymbols(location.SourceSpan.Start, name: argumentName).FirstOrDefault();
if (symbol != null)
{
list.Add(Issue(symbol, argumentName.WithoutSuffix(Suffix)));
}
}
}
private FieldDef ParseField(FieldDeclarationSyntax fieldSyntax, SemanticModel semanticModel)
{
var fieldDef = new FieldDef();
if (fieldSyntax.Declaration.Variables.Count != 1)
{
var span = fieldSyntax.SyntaxTree.GetLineSpan(fieldSyntax.Declaration.Variables.Span);
throw new ParseException(string.Format("{0} : 変数の複数同時宣言は禁止です。", span));
}
var declaration = fieldSyntax.Declaration;
var variable = fieldSyntax.Declaration.Variables[0];
// 主にfixed配列対象
ArgumentSyntax arguments = null;
if (variable.ArgumentList != null)
{
arguments = variable.ArgumentList.Arguments.FirstOrDefault();
}
var type = ParseTypeSpecifier(declaration.Type, semanticModel);
// 無理やり書き換える
if (arguments != null)
{
if (type is SimpleType)
{
var at = new ArrayType();
at.BaseType = (SimpleType)type;
type = at;
}
fieldDef.Argument = arguments.ToString();
}
fieldDef.Internal = fieldSyntax;
fieldDef.Name = variable.Identifier.ValueText;
fieldDef.Type = type;
fieldDef.AccessLevel = ParseAccessLevel(fieldSyntax.Modifiers) ?? AccessLevel.Private;
fieldDef.IsStatic = fieldSyntax.Modifiers.Any(x => x.ValueText == "static");
// Summary
var declaredSymbol = semanticModel.GetDeclaredSymbol(fieldSyntax);
var xml = declaredSymbol?.GetDocumentationCommentXml();
fieldDef.Summary = SummaryComment.Parse(xml);
return(fieldDef);
}
private static bool ParameterIsReferenced(ArgumentSyntax argument, IMethodSymbol method)
{
var argumentName = argument.ToString();
return(method.Parameters.Select(_ => _.Name).Any(_ => argumentName == string.Concat("\"", _, "\"") || argumentName == string.Concat("nameof(", _, ")")));
}
private static bool ParameterIsReferenced(ArgumentSyntax argument, IMethodSymbol method)
{
var argumentName = argument.ToString();
return(method.Parameters.Select(_ => _.Name).Any(_ => argumentName == _.SurroundedWithDoubleQuote() || argumentName == AsNameof(_)));
}
private static bool IsValidatedNotNull(string possibleNullReference, BlockSyntax parent, SyntaxNode node,
[NotNullWhen(true)] out SyntaxNode?suppressionCause)
{
suppressionCause = default(SyntaxNode);
StatementSyntax?statement = node?.AncestorsAndSelf().OfType <StatementSyntax>().FirstOrDefault();
var siblings = parent.ChildNodes().ToList();
// Look in earlier statements to see if the variable was previously checked for null.
for (int nodeIndex = siblings.FindIndex(x => x == statement); --nodeIndex >= 0;)
{
SyntaxNode previous = siblings[nodeIndex];
suppressionCause = previous;
if (previous is ExpressionStatementSyntax expressionStatement)
{
if (expressionStatement.Expression is AssignmentExpressionSyntax assignmentExpression)
{
// Is the offending symbol assigned here?
if (InvalidatedBy(assignmentExpression.Left.ToString(), possibleNullReference))
{
return(IsKnownToBeNotNull(assignmentExpression.Right));
}
}
// Check if this is Assert.NotNull or Assert.IsNotNull for the same symbol
if (IsAssert(expressionStatement.Expression, out string member, out ArgumentListSyntax? argumentList))
{
if (member == NunitFrameworkConstants.NameOfAssertNotNull ||
member == NunitFrameworkConstants.NameOfAssertIsNotNull ||
member == NunitFrameworkConstants.NameOfAssertThat)
{
if (member == NunitFrameworkConstants.NameOfAssertThat)
{
// We must check the 2nd argument for anything but "Is.Null"
// E.g.: Is.Not.Null.And.Not.Empty.
ArgumentSyntax?secondArgument = argumentList.Arguments.ElementAtOrDefault(1);
if (secondArgument?.ToString() == "Is.Null")
{
continue;
}
}
ArgumentSyntax firstArgument = argumentList.Arguments.First();
if (CoveredBy(firstArgument.Expression.ToString(), possibleNullReference))
{
return(true);
}
}
}
}
else if (previous is LocalDeclarationStatementSyntax localDeclarationStatement)
{
VariableDeclarationSyntax declaration = localDeclarationStatement.Declaration;
foreach (var variable in declaration.Variables)
{
if (variable.Identifier.ToString() == possibleNullReference)
{
return(IsKnownToBeNotNull(variable.Initializer?.Value));
}
}
}
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="argumentSyntax">Node of ArgumentSyntax type</param>
/// <returns>Trimed and without special character ToString representation.</returns>
public static string ToCleanString(this ArgumentSyntax argumentSyntax)
{
return(argumentSyntax.ToString().Replace("\"", "").Trim());
}
public static string ResolveSymbolToTypeName(this ArgumentSyntax arg, Document doc)
{
string arg_text = arg.ToString();
if (arg_text.IsString())
{
return("string");
}
else if (arg_text.IsChar())
{
return("char");
}
else if (arg_text.IsChar())
{
return("char");
}
else if (arg_text.IsFloat())
{
return("float");
}
else if (arg_text.IsDecimal())
{
return("decimal");
}
else if (arg_text.IsDouble())
{
return("double");
}
else if (arg_text.IsByte())
{
return("byte");
}
else if (arg_text.IsLong())
{
return("long");
}
else if (arg_text.IsSbyte())
{
return("sbyte");
}
else if (arg_text.IsShort())
{
return("short");
}
else if (arg_text.IsUlong())
{
return("ulong");
}
else if (arg_text.IsInt())
{
return("int");
}
else if (arg_text.IsBool())
{
return("bool");
}
// if (arg_text.All(c => char.Is c.IsN "'") && arg_text.EndsWith("\'"))
// {
// return "char";
// }
// var pos = arg.FullSpan.End - 1;
// var arg_type = SymbolFinder.FindSymbolAtPositionAsync(doc, pos).Result;
return("");
}
