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