public override void VisitInvocationExpression(InvocationExpressionSyntax node) { string fileName = Path.GetFileName(node.SyntaxTree.FilePath); FileLinePositionSpan lineSpan = node.SyntaxTree.GetLineSpan(node.Span); int numLine = lineSpan.StartLinePosition.Line + 1; switch (node.Expression.ToString()) { case "Label.Breakpoint": string name = node.ArgumentList.Arguments[0].Expression.ToString(); // "name" -> name name = name.Trim(new char[] { '\"' }); LineBreakpoint lbp = (LineBreakpoint)Activator.CreateInstance(TypeClassBP, name, fileName, numLine); TestLabelsInfo.Breakpoints.Add(name, lbp); break; case "Label.Checkpoint": string id = node.ArgumentList.Arguments[0].Expression.ToString(); string next_id = node.ArgumentList.Arguments[1].Expression.ToString(); // "id" -> id id = id.Trim(new char[] { '\"' }); next_id = next_id.Trim(new char[] { '\"' }); TestLabelsInfo.CheckPointInvokes.Add( id, new Tuple <string, InvocationExpressionSyntax>(next_id, node)); break; } }
private DiagnosticResult AppendSpan(FileLinePositionSpan span) { FileLinePositionSpan[] newSpans; if (this.spans != null) { newSpans = new FileLinePositionSpan[this.spans.Length + 1]; Array.Copy(this.spans, newSpans, this.spans.Length); newSpans[this.spans.Length] = span; } else { newSpans = new FileLinePositionSpan[1] { span, }; } // clone the object, so that the fluent syntax will work on immutable objects. return(new DiagnosticResult { Id = this.Id, Message = this.message, MessageFormat = this.MessageFormat, MessageArguments = this.MessageArguments, Severity = this.Severity, Spans = newSpans, }); }
/// <summary> /// Helper method to VerifyDiagnosticResult that checks the location of a diagnostic and compares it with the location in the expected DiagnosticResult. /// </summary> /// <param name="analyzer">The analyzer that was being run on the sources</param> /// <param name="diagnostic">The diagnostic that was found in the code</param> /// <param name="actual">The Location of the Diagnostic found in the code</param> /// <param name="expected">The DiagnosticResultLocation that should have been found</param> private void VerifyDiagnosticLocation(DiagnosticAnalyzer analyzer, Diagnostic diagnostic, Location actual, DiagnosticResultLocation expected) { FileLinePositionSpan actualSpan = actual.GetLineSpan(); Assert.IsTrue(actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")), $"Expected diagnostic to be in file \"{expected.Path}\" was actually in file \"{actualSpan.Path}\"\r\n\r\nDiagnostic:\r\n {FormatDiagnostics(analyzer, diagnostic)}\r\n"); LinePosition actualLinePosition = actualSpan.StartLinePosition; // Only check line position if there is an actual line in the real diagnostic if (actualLinePosition.Line > 0) { if (actualLinePosition.Line + 1 != expected.Line) { Assert.IsTrue(false, $"Expected diagnostic to be on line \"{expected.Line}\" was actually on line \"{actualLinePosition.Line + 1}\"\r\n\r\nDiagnostic:\r\n {FormatDiagnostics(analyzer, diagnostic)}\r\n"); } } // Only check column position if there is an actual column position in the real diagnostic if (actualLinePosition.Character > 0) { if (actualLinePosition.Character + 1 != expected.Column) { Assert.IsTrue(false, $"Expected diagnostic to start at column \"{expected.Column}\" was actually at column \"{actualLinePosition.Character + 1}\"\r\n\r\nDiagnostic:\r\n {FormatDiagnostics(analyzer, diagnostic)}\r\n"); } } }
public void GetAdjustedDiagnosticSpan( DocumentId documentId, Location location, out TextSpan sourceSpan, out FileLinePositionSpan originalLineInfo, out FileLinePositionSpan mappedLineInfo) { sourceSpan = location.SourceSpan; originalLineInfo = location.GetLineSpan(); mappedLineInfo = location.GetMappedLineSpan(); // Update the original source span, if required. LinePositionSpan originalSpan; LinePositionSpan mappedSpan; if (!TryAdjustSpanIfNeededForVenus(documentId, originalLineInfo, mappedLineInfo, out originalSpan, out mappedSpan)) { return; } if (originalSpan.Start != originalLineInfo.StartLinePosition || originalSpan.End != originalLineInfo.EndLinePosition) { originalLineInfo = new FileLinePositionSpan(originalLineInfo.Path, originalSpan.Start, originalSpan.End); var textLines = location.SourceTree.GetText().Lines; var startPos = textLines.GetPosition(originalSpan.Start); var endPos = textLines.GetPosition(originalSpan.End); sourceSpan = new TextSpan(startPos, endPos - startPos); } if (mappedSpan.Start != mappedLineInfo.StartLinePosition || mappedSpan.End != mappedLineInfo.EndLinePosition) { mappedLineInfo = new FileLinePositionSpan(mappedLineInfo.Path, mappedSpan.Start, mappedSpan.End); } }
private bool TryAdjustSpanIfNeededForVenus( DocumentId documentId, FileLinePositionSpan originalLineInfo, FileLinePositionSpan mappedLineInfo, out LinePositionSpan originalSpan, out LinePositionSpan mappedSpan) { var startChanged = true; MappedSpan startLineColumn; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, out startLineColumn)) { startChanged = false; startLineColumn = new MappedSpan(originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, mappedLineInfo.StartLinePosition.Line, mappedLineInfo.StartLinePosition.Character); } var endChanged = true; MappedSpan endLineColumn; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, out endLineColumn)) { endChanged = false; endLineColumn = new MappedSpan(originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, mappedLineInfo.EndLinePosition.Line, mappedLineInfo.EndLinePosition.Character); } // start and end position can be swapped when mapped between primary and secondary buffer if start position is within visible span (at the edge) // but end position is outside of visible span. in that case, swap start and end position. originalSpan = GetLinePositionSpan(startLineColumn.OriginalLinePosition, endLineColumn.OriginalLinePosition); mappedSpan = GetLinePositionSpan(startLineColumn.MappedLinePosition, endLineColumn.MappedLinePosition); return startChanged || endChanged; }
internal static async Task <long> GetLinesOfCodeAsync(ImmutableArray <SyntaxReference> declarations, ISymbol symbol, CodeMetricsAnalysisContext context) { long linesOfCode = 0; foreach (var decl in declarations) { SyntaxNode declSyntax = await GetTopmostSyntaxNodeForDeclarationAsync(decl, symbol, context).ConfigureAwait(false); // For namespace symbols, don't count lines of code for declarations of child namespaces. // For example, "namespace N1.N2 { }" is a declaration reference for N1, but the actual declaration is for N2. if (symbol.Kind == SymbolKind.Namespace) { var model = context.GetSemanticModel(declSyntax); if (model.GetDeclaredSymbol(declSyntax, context.CancellationToken) != (object)symbol) { continue; } } FileLinePositionSpan linePosition = declSyntax.SyntaxTree.GetLineSpan(declSyntax.FullSpan, context.CancellationToken); long delta = linePosition.EndLinePosition.Line - linePosition.StartLinePosition.Line; if (delta == 0) { // Declaration on a single line, we count it as a separate line. delta = 1; } linesOfCode += delta; } return(linesOfCode); }
public void GetAdjustedDiagnosticSpan( DocumentId documentId, Location location, out TextSpan sourceSpan, out FileLinePositionSpan originalLineInfo, out FileLinePositionSpan mappedLineInfo) { sourceSpan = location.SourceSpan; originalLineInfo = location.GetLineSpan(); mappedLineInfo = location.GetMappedLineSpan(); // check quick bail out case. if (location == Location.None) { return; } // Update the original source span, if required. if (!TryAdjustSpanIfNeededForVenus(documentId, originalLineInfo, mappedLineInfo, out var originalSpan, out var mappedSpan)) { return; } if (originalSpan.Start != originalLineInfo.StartLinePosition || originalSpan.End != originalLineInfo.EndLinePosition) { originalLineInfo = new FileLinePositionSpan(originalLineInfo.Path, originalSpan.Start, originalSpan.End); var textLines = location.SourceTree.GetText().Lines; var startPos = textLines.GetPosition(originalSpan.Start); var endPos = textLines.GetPosition(originalSpan.End); sourceSpan = TextSpan.FromBounds(startPos, Math.Max(startPos, endPos)); } if (mappedSpan.Start != mappedLineInfo.StartLinePosition || mappedSpan.End != mappedLineInfo.EndLinePosition) { mappedLineInfo = new FileLinePositionSpan(mappedLineInfo.Path, mappedSpan.Start, mappedSpan.End); } }
/// <summary> /// Calculate node comment lines /// </summary> /// <param name="node"></param> /// <returns>Sum of comment lines</returns> private static int SumCommentLines(SyntaxNode node) { int tcloc = 0; var list = node.DescendantTrivia().Where(t => t.IsAcceptableCommentKind()).ToList(); foreach (var trivia in list) { SyntaxNode localNode = trivia.Token.Parent; if (node.IsAcceptableToInsideNode(localNode)) { continue; } FileLinePositionSpan flps = trivia.GetLocation().GetLineSpan(); switch (trivia.Kind()) { case SyntaxKind.MultiLineCommentTrivia: case SyntaxKind.SingleLineCommentTrivia: case SyntaxKind.MultiLineDocumentationCommentTrivia: if (localNode.IsParent <BlockSyntax>()) { tcloc += flps.EndLinePosition.Line - flps.StartLinePosition.Line + 1; } break; case SyntaxKind.SingleLineDocumentationCommentTrivia: if (localNode.IsParent <BlockSyntax>()) { tcloc += flps.EndLinePosition.Line - flps.StartLinePosition.Line; } break; } } return(tcloc); }
private IDictionary <int, TextSpan> getLineSpans(SyntaxTree tree, IEnumerable <SyntaxToken> tokens) { Dictionary <int, TextSpan> dict = new Dictionary <int, TextSpan>(); foreach (SyntaxToken t in tokens) { TextSpan span = t.Span; if (span.Length == 0) { continue; } FileLinePositionSpan linePos = tree.GetLineSpan(span); int line = linePos.StartLinePosition.Line; if (dict.ContainsKey(line)) { if (span.Start < dict[line].Start) { dict[line] = TextSpan.FromBounds(span.Start, dict[line].End); } if (span.End > dict[line].End) { dict[line] = TextSpan.FromBounds(dict[line].Start, span.End); } } else { dict[line] = span; } } return(dict); }
internal void TraceCompilationDiagnostics(ImmutableArray <Diagnostic> diagnostics, LogTargets logTarget = LogTargets.All, bool isInvocation = false) { if (logTarget == LogTargets.None) { return; } // build the log state based on inputs Dictionary <string, object> logState = new Dictionary <string, object>(); if (!isInvocation) { // generally we only want to trace compilation diagnostics on the single primary // host, to avoid duplicate log statements in the case of file save operations. // however if the function is being invoked, we always want to output detailed // information. logState.Add(ScriptConstants.LogPropertyPrimaryHostKey, true); } if (!logTarget.HasFlag(LogTargets.User)) { logState.Add(ScriptConstants.LogPropertyIsSystemLogKey, true); } else if (!logTarget.HasFlag(LogTargets.System)) { logState.Add(ScriptConstants.LogPropertyIsUserLogKey, true); } // log the diagnostics foreach (var diagnostic in diagnostics.Where(d => !d.IsSuppressed)) { FunctionLogger.Log(diagnostic.Severity.ToLogLevel(), 0, logState, null, (s, e) => diagnostic.ToString()); } // log structured logs if (Host.InDebugMode && (Host.IsPrimary || isInvocation)) { Host.EventManager.Publish(new StructuredLogEntryEvent(() => { var logEntry = new StructuredLogEntry("codediagnostic"); logEntry.AddProperty("functionName", Metadata.Name); logEntry.AddProperty("diagnostics", diagnostics.Select(d => { FileLinePositionSpan span = d.Location.GetMappedLineSpan(); return(new { code = d.Id, message = d.GetMessage(), source = Path.GetFileName(d.Location.SourceTree?.FilePath ?? span.Path ?? string.Empty), severity = d.Severity, startLineNumber = span.StartLinePosition.Line + 1, startColumn = span.StartLinePosition.Character + 1, endLine = span.EndLinePosition.Line + 1, endColumn = span.EndLinePosition.Character + 1, }); })); return(logEntry); })); } }
private bool TryAdjustSpanIfNeededForVenus( DocumentId documentId, FileLinePositionSpan originalLineInfo, FileLinePositionSpan mappedLineInfo, out LinePositionSpan originalSpan, out LinePositionSpan mappedSpan) { var startChanged = true; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, out var startLineColumn)) { startChanged = false; startLineColumn = new MappedSpan(originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, mappedLineInfo.StartLinePosition.Line, mappedLineInfo.StartLinePosition.Character); } var endChanged = true; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, out var endLineColumn)) { endChanged = false; endLineColumn = new MappedSpan(originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, mappedLineInfo.EndLinePosition.Line, mappedLineInfo.EndLinePosition.Character); } // start and end position can be swapped when mapped between primary and secondary buffer if start position is within visible span (at the edge) // but end position is outside of visible span. in that case, swap start and end position. originalSpan = GetLinePositionSpan(startLineColumn.OriginalLinePosition, endLineColumn.OriginalLinePosition); mappedSpan = GetLinePositionSpan(startLineColumn.MappedLinePosition, endLineColumn.MappedLinePosition); return(startChanged || endChanged); }
private static void HandleBlock(SyntaxNodeAnalysisContext context) { BlockSyntax block = context.Node as BlockSyntax; if (block != null && block.Statements.Any()) { var previousStatement = block.Statements[0]; FileLinePositionSpan previousStatementLocation = previousStatement.GetLineSpan(); FileLinePositionSpan currentStatementLocation; for (int i = 1; i < block.Statements.Count; i++) { var currentStatement = block.Statements[i]; currentStatementLocation = currentStatement.GetLineSpan(); if (previousStatementLocation.EndLinePosition.Line == currentStatementLocation.StartLinePosition.Line && !IsLastTokenMissing(previousStatement)) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, block.Statements[i].GetLocation())); } previousStatementLocation = currentStatementLocation; previousStatement = currentStatement; } } }
void LogException(CompileTaskResult result, System.Exception e, SyntaxNode node, out string logMessage) { logMessage = ""; if (node != null) { FileLinePositionSpan lineSpan = node.GetLocation().GetLineSpan(); CompileError error = new CompileError(); error.script = programAsset.sourceCsScript; error.errorStr = $"{e.GetType()}: {e.Message}"; error.lineIdx = lineSpan.StartLinePosition.Line; error.charIdx = lineSpan.StartLinePosition.Character; result.compileErrors.Add(error); } else { logMessage = e.ToString(); Debug.LogException(e); } #if UDONSHARP_DEBUG Debug.LogException(e); Debug.LogError(e.StackTrace); #endif }
/// <summary> /// Helper method to VerifyDiagnosticResult that checks the location of a diagnostic and compares it with the location in the expected DiagnosticResult. /// </summary> /// <param name="analyzer">The analyzer that was being run on the sources</param> /// <param name="diagnostic">The diagnostic that was found in the code</param> /// <param name="actual">The Location of the Diagnostic found in the code</param> /// <param name="expected">The DiagnosticResultLocation that should have been found</param> private static void VerifyDiagnosticLocation(DiagnosticAnalyzer analyzer, Diagnostic diagnostic, Location actual, DiagnosticLocation expected) { FileLinePositionSpan actualSpan = actual.GetLineSpan(); Assert.True(actualSpan.Path == expected.Span.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Span.Path.Contains("Test.")), string.Format("Expected diagnostic to be in file \"{0}\" was actually in file \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n", expected.Span.Path, actualSpan.Path, FormatDiagnostics(analyzer, diagnostic))); Microsoft.CodeAnalysis.Text.LinePosition actualLinePosition = actualSpan.StartLinePosition; // Only check line position if there is an actual line in the real diagnostic if (expected.Span.StartLinePosition.Line > 0) { if (actualLinePosition.Line + 1 != expected.Span.StartLinePosition.Line) { Assert.True(false, string.Format("Expected diagnostic to be on line \"{0}\" was actually on line \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n", expected.Span.StartLinePosition.Line, actualLinePosition.Line + 1, FormatDiagnostics(analyzer, diagnostic))); } } // Only check column position if there is an actual column position in the real diagnostic if (actualLinePosition.Character > 0) { if (actualLinePosition.Character + 1 != expected.Span.StartLinePosition.Character) { Assert.True(false, string.Format("Expected diagnostic to start at column \"{0}\" was actually at column \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n", expected.Span.StartLinePosition.Character, actualLinePosition.Character + 1, FormatDiagnostics(analyzer, diagnostic))); } } }
private static XElement SerializeDiagnostic(Diagnostic diagnostic, IFormatProvider formatProvider) { XElement filePathElement = null; XElement locationElement = null; FileLinePositionSpan span = diagnostic.Location.GetMappedLineSpan(); if (span.IsValid) { filePathElement = new XElement("FilePath", span.Path); LinePosition linePosition = span.Span.Start; locationElement = new XElement("Location", new XAttribute("Line", linePosition.Line + 1), new XAttribute("Character", linePosition.Character + 1)); } return(new XElement( "Diagnostic", new XAttribute("Id", diagnostic.Id), new XElement("Severity", diagnostic.Severity), new XElement("Message", diagnostic.GetMessage(formatProvider)), filePathElement, locationElement)); }
public MethodContext(MethodInfo method, MetaContext context, FileLinePositionSpan methodSpan, string fileName) { Context = context; Method = method; MethodSpan = methodSpan; FileName = fileName; }
internal void AddMessage(string text, SyntaxNode node, TranslationMessageType type = TranslationMessageType.Error) { Location loc = node.GetLocation(); FileLinePositionSpan span = loc.GetLineSpan(); AddMessage(text, span.StartLinePosition.Line, span.StartLinePosition.Character, type); }
public SyntaxNodeOrTokenListItem(SyntaxNodeOrToken syntaxNodeOrToken) { _lineSpan = syntaxNodeOrToken.GetLocation().GetLineSpan(); Content = $"{_lineSpan}: {syntaxNodeOrToken.Kind()} {Truncate(syntaxNodeOrToken.ToString())}"; ToolTip = syntaxNodeOrToken.ToString(); }
protected static bool HasNoBlankLinesAfter(FileLinePositionSpan callLineSpan, StatementSyntax other) { var otherLineSpan = other.GetLocation().GetLineSpan(); var differenceAfter = otherLineSpan.StartLinePosition.Line - callLineSpan.EndLinePosition.Line; return(differenceAfter == 1); }
public async Task ShouldCreateDiagnosticWithCorrectLocation() { var diagnostics = await SetupAndGetDiagnosticsAsync(); var expectedSpan = new FileLinePositionSpan("Class1.cs", new LinePosition(5, 10), new LinePosition(5, 15)); diagnostics.Should().Contain(d => d.Location.GetLineSpan().Equals(expectedSpan)); }
public static void RegisterRefactoring(RefactoringContext context, MemberDeclarationSyntax member) { FileLinePositionSpan fileSpan = GetFileLinePositionSpan(member, context.CancellationToken); context.RegisterRefactoring( $"Comment out {member.GetTitle()}", cancellationToken => RefactorAsync(context.Document, fileSpan.StartLine(), fileSpan.EndLine(), cancellationToken)); }
public static void RegisterRefactoring(RefactoringContext context, LocalFunctionStatementSyntax localFunctionStatement) { FileLinePositionSpan fileSpan = GetFileLinePositionSpan(localFunctionStatement, context.CancellationToken); context.RegisterRefactoring( $"Comment out {localFunctionStatement.GetTitle()}", cancellationToken => RefactorAsync(context.Document, fileSpan.StartLine(), fileSpan.EndLine(), cancellationToken)); }
internal /* for testing */ static TextRange GetTextRange(FileLinePositionSpan lineSpan) => new TextRange { StartLine = lineSpan.StartLinePosition.GetLineNumberToReport(), EndLine = lineSpan.EndLinePosition.GetLineNumberToReport(), StartOffset = lineSpan.StartLinePosition.Character, EndOffset = lineSpan.EndLinePosition.Character };
public static void RegisterRefactoring(RefactoringContext context, StatementSyntax statement) { FileLinePositionSpan fileSpan = statement.SyntaxTree.GetLineSpan(statement.Span, context.CancellationToken); context.RegisterRefactoring( "Comment out statement", ct => RefactorAsync(context.Document, fileSpan.StartLine(), fileSpan.EndLine(), ct)); }
private static string GetNotInExpectedFileMessage( DiagnosticAnalyzer analyzer, Diagnostic diagnostic, DiagnosticResultLocation expected, FileLinePositionSpan actualSpan) { return($"Expected diagnostic to be in file \"{expected.Path}\" was actually in file \"{actualSpan.Path}\"{Environment.NewLine}{Environment.NewLine}Diagnostic:{Environment.NewLine} {FormatDiagnostics(analyzer, new[] { diagnostic })}{Environment.NewLine}"); }
private static string CreateErrorMessage(SyntaxNode node, string message) { FileLinePositionSpan span = node.SyntaxTree.GetLineSpan(node.Span); int lineNumber = span.StartLinePosition.Line; int characterNumber = span.StartLinePosition.Character; return($"({lineNumber}, {characterNumber}): {message}"); }
public static void ComputeRefactoring(RefactoringContext context, MemberDeclarationSyntax member) { MemberDeclarationListInfo info = SyntaxInfo.MemberDeclarationListInfo(member.Parent); if (!info.Success) { return; } SyntaxList <MemberDeclarationSyntax> members = info.Members; if (members.Count <= 1) { return; } int index = IndexOfMemberToSwap(member, members, context.Span); if (index == -1) { return; } SyntaxTree tree = member.SyntaxTree; FileLinePositionSpan fileLinePositionSpan = tree.GetLineSpan(context.Span, context.CancellationToken); int startLine = fileLinePositionSpan.StartLine(); int endLine = fileLinePositionSpan.EndLine(); if (startLine <= tree.GetEndLine(members[index].TrimmedSpan(), context.CancellationToken)) { return; } if (endLine >= tree.GetStartLine(members[index + 1].TrimmedSpan(), context.CancellationToken)) { return; } if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveMemberDeclarations)) { context.RegisterRefactoring( "Remove members above", ct => ReplaceMembersAsync(context.Document, info, members.Skip(index + 1), ct)); context.RegisterRefactoring( "Remove members below", ct => ReplaceMembersAsync(context.Document, info, members.Take(index + 1), ct)); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapMemberDeclarations)) { context.RegisterRefactoring( "Swap members", ct => SwapMembersAsync(context.Document, info, index, ct)); } }
public List <Metodo> Construya(SyntaxList <MemberDeclarationSyntax> losNodos, string elIdSolucion) { List <MethodDeclarationSyntax> losMetodosDeclarados = new List <MethodDeclarationSyntax>(); List <Metodo> losMetodosConvertidos = new List <Metodo>(); if (losNodos != null && losNodos.Count != 0) { Convertidor elConvertidor = new Convertidor(); losMetodosDeclarados = elConvertidor.Convierta(losNodos, elIdSolucion); foreach (MethodDeclarationSyntax elMetodo in losMetodosDeclarados) { try { Metodo elMetodoConvertido = new Metodo(); elMetodoConvertido.NombreMetodo = elMetodo.Identifier.Text; elMetodoConvertido.Retorno = elMetodo.ReturnType.ToString(); FileLinePositionSpan lineSpan = elMetodo.SyntaxTree.GetLineSpan(elMetodo.Span); elMetodoConvertido.LineaComienzo = lineSpan.StartLinePosition.Line; elMetodoConvertido.LineaFinal = lineSpan.EndLinePosition.Line; string elModificador; if (elMetodo.Modifiers.Count == 0) { elModificador = ""; } else { elModificador = elMetodo.Modifiers.First().ToString(); } elMetodoConvertido.Visibilidad = elModificador; Parametros.Constructor elConstructorDeParametros = new Parametros.Constructor(); elMetodoConvertido.Parametros = elConstructorDeParametros.Construya(elMetodo.ParameterList.Parameters, elIdSolucion).ToArray(); Controles.Constructor elConstructorDeControles = new Controles.Constructor(); if (elMetodo.Body != null) { elMetodoConvertido.Controles = elConstructorDeControles.Construya(elMetodo.Body.Statements, elIdSolucion).ToArray(); } else { elMetodoConvertido.Controles = new List <Control>().ToArray(); } losMetodosConvertidos.Add(elMetodoConvertido); } catch (Exception laExcepcion) { Bitacoras.Registrador elRegistrador = new Bitacoras.Registrador(); elRegistrador.Registre(laExcepcion, elIdSolucion, BC.Componentes.AnalizadorCodigoFuente); } } } return(losMetodosConvertidos); }
public ExternalFilePeekableItem( FileLinePositionSpan span, IPeekRelationship relationship, IPeekResultFactory peekResultFactory) : base(peekResultFactory) { _span = span; _relationship = relationship; }
private static void VerifyFileLinePositionSpan( FileLinePositionSpan actual, FileLinePositionSpan expected) { actual.Path.Should().Be(expected.Path); VerifyLinePosition(actual.StartLinePosition, expected.StartLinePosition, "start"); VerifyLinePosition(actual.EndLinePosition, expected.EndLinePosition, "end"); }
private static Diff CreateDiff(FileLinePositionSpan fileLinePositionSpan, string text) { var start = new Position(fileLinePositionSpan.StartLinePosition.Line + 1, fileLinePositionSpan.StartLinePosition.Character); var end = new Position(fileLinePositionSpan.EndLinePosition.Line + 1, fileLinePositionSpan.EndLinePosition.Character); return(new Diff(text, new Gauge.Dotnet.Models.Range(start, end))); }
public static void RegisterRefactoring(RefactoringContext context, LocalFunctionStatementSyntax localFunctionStatement) { FileLinePositionSpan fileSpan = GetFileLinePositionSpan(localFunctionStatement, context.CancellationToken); context.RegisterRefactoring( $"Comment out {CSharpFacts.GetTitle(localFunctionStatement)}", ct => RefactorAsync(context.Document, fileSpan.StartLine(), fileSpan.EndLine(), ct), RefactoringDescriptors.CommentOutMemberDeclaration); }
/// <summary> /// Generates dead checking if statement with injected body block /// </summary> /// <param name="body"></param> /// <param name="resumeLocation"></param> /// <returns></returns> StatementSyntax DeadCheckIfStatement(StatementSyntax body, FileLinePositionSpan resumeLocation) { return(SyntaxFactory.IfStatement( SyntaxFactory.PrefixUnaryExpression( SyntaxKind.LogicalNotExpression, IsDeadCall()), InjectedBlock(body, resumeLocation) )); }
internal AnalysisResult(ISharpenSuggestion suggestion, SingleSyntaxTreeAnalysisContext analysisContext, string filePath, SyntaxToken startingToken, SyntaxNode displayTextNode) { this.displayTextNode = displayTextNode; Suggestion = suggestion; AnalysisContext = analysisContext; FilePath = filePath; Position = startingToken.GetLocation().GetLineSpan(); }
/// <summary> /// Gets a document location from a line span. /// </summary> /// <param name="span">The line span.</param> /// <returns>A new document location.</returns> internal static DocumentLocation FromSpan(FileLinePositionSpan span) { return new DocumentLocation { LineStart = span.StartLinePosition.Line + 1, ColumnStart = span.StartLinePosition.Character + 1, LineEnd = span.EndLinePosition.Line + 1, ColumnEnd = span.EndLinePosition.Character + 1 }; }
public void SaneHashCode() { var hash1 = new FileLinePositionSpan("C:\\foo.cs", new LinePosition(1, 2), new LinePosition(3, 5)).GetHashCode(); var hash2 = new FileLinePositionSpan("C:\\foo1.cs", new LinePosition(1, 2), new LinePosition(3, 5)).GetHashCode(); var hash3 = new FileLinePositionSpan("C:\\foo.cs", new LinePosition(1, 3), new LinePosition(3, 5)).GetHashCode(); var hash4 = new FileLinePositionSpan("C:\\foo.cs", new LinePosition(1, 1), new LinePosition(6, 5)).GetHashCode(); Assert.NotEqual(hash1, hash2); Assert.NotEqual(hash1, hash3); Assert.NotEqual(hash1, hash4); Assert.NotEqual(hash2, hash3); Assert.NotEqual(hash2, hash4); Assert.NotEqual(hash3, hash4); }
private static void Analyze( SyntaxNodeAnalysisContext context, FileLinePositionSpan declarationLineSpan, SyntaxList<TypeParameterConstraintClauseSyntax> constraintClauses) { int currentLine = declarationLineSpan.StartLinePosition.Line; foreach (var constraint in constraintClauses) { int constraintLine = constraint.GetLineSpan().StartLinePosition.Line; if (currentLine == constraintLine) { context.ReportDiagnostic(Diagnostic.Create(Descriptor, constraint.GetLocation())); } currentLine = constraintLine; } }
/// <summary> /// Initializes a new instance of <see cref="RoslynCompilationMessage"/>. /// </summary> /// <param name="diagnostic">The <see cref="Diagnostic"/> instance to read /// diagnostic details from.</param> public RoslynCompilationMessage(Diagnostic diagnostic) { _diagnostic = diagnostic; _mappedLineSpan = _diagnostic.Location.GetMappedLineSpan(); switch (_diagnostic.Severity) { case DiagnosticSeverity.Error: Severity = CompilationMessageSeverity.Error; break; case DiagnosticSeverity.Warning: Severity = CompilationMessageSeverity.Warning; break; default: Severity = CompilationMessageSeverity.Info; break; } }
internal void InspectWithFavoriteCodeEditor(string folder, FileLinePositionSpan? span = null) { if (span != null) { FileLinePositionSpan s = (FileLinePositionSpan)span; // when working locally on windows we can pop up vs code to see if the code failure. if (!StartVsCode( folder, "-g", $"{Path.Combine(folder, s.Path)}:{s.StartLinePosition.Line + 1}:{s.StartLinePosition.Character + 1}")) { // todo: add code here to try another editor? } } else { StartVsCode(folder); } }
public static void SelectSpanInCodeWindow(FileLinePositionSpan span) { // If the path is not available we cannot jump to it if (string.IsNullOrEmpty(span.Path)) return; // Check if the document is opened, if not open it. IVsUIHierarchy hierarchy; uint itemId; IVsWindowFrame windowFrame; if (!VsShellUtilities.IsDocumentOpen(ServiceProvider.GlobalProvider, span.Path, VSConstants.LOGVIEWID_Any, out hierarchy, out itemId, out windowFrame)) { VsShellUtilities.OpenDocument(ServiceProvider.GlobalProvider, span.Path, VSConstants.LOGVIEWID_Primary, out hierarchy, out itemId, out windowFrame); } var window = VsShellUtilities.GetWindowObject(windowFrame); window.SetFocus(); var textView = VsShellUtilities.GetTextView(windowFrame); textView.SetSelection(span.StartLinePosition.Line, span.StartLinePosition.Character, span.EndLinePosition.Line, span.EndLinePosition.Character); }
public void Ctor1() { Assert.Throws( typeof(ArgumentNullException), () => { var notUsed = new FileLinePositionSpan(null, new LinePosition(1, 2), new LinePosition(3, 5)); }); Assert.Throws( typeof(ArgumentException), () => { var notUsed = new FileLinePositionSpan("C:\\foo.cs", new LinePosition(3, 2), new LinePosition(2, 4)); }); Assert.Throws( typeof(ArgumentException), () => { var notUsed = new FileLinePositionSpan("C:\\foo.cs", new LinePosition(1, 2), new LinePosition(1, 1)); }); }
private bool TryAdjustSpanIfNeededForVenus( DocumentId documentId, FileLinePositionSpan originalLineInfo, FileLinePositionSpan mappedLineInfo, out LinePositionSpan originalSpan, out LinePositionSpan mappedSpan) { var startChanged = true; MappedSpan startLineColumn; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, out startLineColumn)) { startChanged = false; startLineColumn = new MappedSpan(originalLineInfo.StartLinePosition.Line, originalLineInfo.StartLinePosition.Character, mappedLineInfo.StartLinePosition.Line, mappedLineInfo.StartLinePosition.Character); } var endChanged = true; MappedSpan endLineColumn; if (!TryAdjustSpanIfNeededForVenus(_workspace, documentId, originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, out endLineColumn)) { endChanged = false; endLineColumn = new MappedSpan(originalLineInfo.EndLinePosition.Line, originalLineInfo.EndLinePosition.Character, mappedLineInfo.EndLinePosition.Line, mappedLineInfo.EndLinePosition.Character); } originalSpan = new LinePositionSpan(startLineColumn.OriginalLinePosition, Max(startLineColumn.OriginalLinePosition, endLineColumn.OriginalLinePosition)); mappedSpan = new LinePositionSpan(startLineColumn.MappedLinePosition, Max(startLineColumn.MappedLinePosition, endLineColumn.MappedLinePosition)); return startChanged || endChanged; }
public CompleterError(SyntaxTree tree, Message message, FileLinePositionSpan span) { Tree = tree; Span = span; Message = message; }
internal WorkItemInfo? GetUpdatedWorkItemInfo(string filePath, FileLinePositionSpan loc, int id, string description) { if (StringComparer.OrdinalIgnoreCase.Equals("devdiv", description)) { if (_workItemData.IsDevDivTfsBug(id)) { return new WorkItemInfo(id, string.Format(UrlDevDiv, id)); } } if (string.IsNullOrEmpty(description)) { if (_workItemData.IsDevDivTfsBug(id)) { return new WorkItemInfo(id, string.Format(UrlDevDiv, id)); } if (_workItemData.IsGithubBug(id) && !_workItemData.IsRoslynBug(id)) { return new WorkItemInfo(id, string.Format(UrlGithub, id)); } if (!_workItemData.IsGithubBug(id) && _workItemData.IsRoslynBug(id)) { return new WorkItemInfo(id, string.Format(UrlRoslyn, id)); } if (id > 100000 && _workItemData.IsDevDivTfsBug(id, checkAreaPath: false)) { return new WorkItemInfo(id, string.Format(UrlDevDiv, id)); } _unknownList.Add($"{filePath} line {loc.StartLinePosition.Line} id {id}"); } if (RewriteUrl(id, ref description)) { return new WorkItemInfo(id, description); } Uri uri; if (!Uri.TryCreate(description, UriKind.Absolute, out uri)) { _unknownList.Add($"Bad Url {filePath} {loc.StartLinePosition.Line}"); } return null; }
private Value GetSpanInfoValue(FileLinePositionSpan lineSpan) { // Note that SARIF region lines and columns are specified to be 1-based, but FileLinePositionSpan.Line and Character are 0-based. var builder = ArrayBuilder<KeyValuePair<string, Value>>.GetInstance(); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanStartLine, lineSpan.StartLinePosition.Line + 1)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanStartColumn, lineSpan.StartLinePosition.Character + 1)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanEndLine, lineSpan.EndLinePosition.Line + 1)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanEndColumn, lineSpan.EndLinePosition.Character + 1)); return Value.Create(builder.ToImmutableAndFree(), this); }
/// <summary> /// Helper method to <see cref="VerifyDiagnosticResults"/> that checks the location of a /// <see cref="Diagnostic"/> and compares it with the location described by a /// <see cref="FileLinePositionSpan"/>. /// </summary> /// <param name="analyzers">The analyzer that have been run on the sources.</param> /// <param name="diagnostic">The diagnostic that was found in the code.</param> /// <param name="actual">The location of the diagnostic found in the code.</param> /// <param name="expected">The <see cref="FileLinePositionSpan"/> describing the expected location of the /// diagnostic.</param> private static void VerifyDiagnosticLocation(ImmutableArray<DiagnosticAnalyzer> analyzers, Diagnostic diagnostic, Location actual, FileLinePositionSpan expected) { var actualSpan = actual.GetLineSpan(); string message = string.Format( "Expected diagnostic to be in file \"{0}\" was actually in file \"{1}\"\r\n\r\nDiagnostic:\r\n {2}\r\n", expected.Path, actualSpan.Path, FormatDiagnostics(analyzers, diagnostic)); Assert.True( actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")), message); var actualStartLinePosition = actualSpan.StartLinePosition; var actualEndLinePosition = actualSpan.EndLinePosition; VerifyLinePosition(analyzers, diagnostic, actualSpan.StartLinePosition, expected.StartLinePosition, "start"); if (expected.StartLinePosition < expected.EndLinePosition) { VerifyLinePosition(analyzers, diagnostic, actualSpan.EndLinePosition, expected.EndLinePosition, "end"); } }
private Value GetSpanInfoValue(FileLinePositionSpan lineSpan) { var builder = ArrayBuilder<KeyValuePair<string, Value>>.GetInstance(); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanStartLine, lineSpan.StartLinePosition.Line)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanStartColumn, lineSpan.StartLinePosition.Character)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanEndLine, lineSpan.EndLinePosition.Line)); builder.Add(CreateSimpleKeyValuePair(WellKnownStrings.LocationSpanEndColumn, lineSpan.EndLinePosition.Character)); return Value.Create(builder.ToImmutableAndFree(), this); }
private Cci.DebugSourceDocument GetSourceDocument(SyntaxNode syntax, FileLinePositionSpan span) { string path = span.Path; // If the path for the syntax node is empty, try the path for the entire syntax tree. if (path.Length == 0) { path = syntax.SyntaxTree.FilePath; } return _debugDocumentProvider.Invoke(path, basePath: ""); }
private static void GetLocationInfo(Document document, Location location, out TextSpan sourceSpan, out FileLinePositionSpan originalLineInfo, out FileLinePositionSpan mappedLineInfo) { var diagnosticSpanMappingService = document.Project.Solution.Workspace.Services.GetService<IWorkspaceVenusSpanMappingService>(); if (diagnosticSpanMappingService != null) { diagnosticSpanMappingService.GetAdjustedDiagnosticSpan(document.Id, location, out sourceSpan, out originalLineInfo, out mappedLineInfo); return; } sourceSpan = location.SourceSpan; originalLineInfo = location.GetLineSpan(); mappedLineInfo = location.GetMappedLineSpan(); }
private DiagnosticResult AppendSpan(FileLinePositionSpan span) { FileLinePositionSpan[] newSpans; if (this.spans != null) { newSpans = new FileLinePositionSpan[this.spans.Length + 1]; Array.Copy(this.spans, newSpans, this.spans.Length); newSpans[this.spans.Length] = span; } else { newSpans = new FileLinePositionSpan[1] { span, }; } // clone the object, so that the fluent syntax will work on immutable objects. return new DiagnosticResult { Id = this.Id, Message = this.message, MessageFormat = this.MessageFormat, MessageArguments = this.MessageArguments, Severity = this.Severity, Spans = newSpans, }; }
private BoundStatement AddAnalysisPoint(SyntaxNode syntaxForSpan, FileLinePositionSpan span, SyntheticBoundNodeFactory statementFactory) { // Add an entry in the spans array. int spansIndex = _spansBuilder.Count; _spansBuilder.Add(new SourceSpan(GetSourceDocument(syntaxForSpan, span), span.StartLinePosition.Line, span.StartLinePosition.Character, span.EndLinePosition.Line, span.EndLinePosition.Character)); // Generate "_payload[pointIndex] = true". BoundArrayAccess payloadCell = statementFactory.ArrayAccess(statementFactory.Local(_methodPayload), statementFactory.Literal(spansIndex)); return statementFactory.Assignment(payloadCell, statementFactory.Literal(true)); }