private static void AppendObject(this HierarchicalStringBuilder builder, Exception?exception)
{
if (exception != null)
{
builder.AppendLine("Exception: {0}", exception);
}
}
// DataFlowAnalysis
public static string GetDisplayString(BlockSyntax syntax, DataFlowAnalysis analysis)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Data flow analysis: {0}", syntax.Parent !.Kind())) {
builder.AppendLine("Definitely assigned (On entry): {0}", analysis.DefinitelyAssignedOnEntry.Join());
builder.AppendLine("Definitely assigned (On exit): {0}", analysis.DefinitelyAssignedOnExit.Join());
builder.AppendLine("Declared (Inside): {0}", analysis.VariablesDeclared.Join());
builder.AppendLine("Always assigned (Inside): {0}", analysis.AlwaysAssigned.Join());
builder.AppendLine("Written (Outside): {0}", analysis.WrittenOutside.Join());
builder.AppendLine("Read (Outside): {0}", analysis.ReadOutside.Join());
builder.AppendLine("Written (Inside): {0}", analysis.WrittenInside.Join());
builder.AppendLine("Read (Inside): {0}", analysis.ReadInside.Join());
builder.AppendLine("Data flows (In): {0}", analysis.DataFlowsIn.Join());
builder.AppendLine("Data flows (Out): {0}", analysis.DataFlowsOut.Join());
builder.AppendLine("Captured: {0}", analysis.Captured.Join());
builder.AppendLine("Captured (Inside): {0}", analysis.CapturedInside.Join());
builder.AppendLine("Captured (Outside): {0}", analysis.CapturedOutside.Join());
builder.AppendLine("Unsafe address taken: {0}", analysis.UnsafeAddressTaken.Join());
builder.AppendLine("Used local functions: {0}", analysis.UsedLocalFunctions.Join());
}
return(builder.ToString());
}
private static void AppendObject(this HierarchicalStringBuilder builder, GeneratedSourceResult[] sources)
{
foreach (var source in sources)
{
builder.AppendLine("Source: {0}", source.HintName).AppendText(source.SourceText);
}
}
// Render/Text/Hierarchical
public static string RenderToHierarchicalText(this ProjectArchNode project)
{
var builder = new HierarchicalStringBuilder();
builder.AppendObject(project);
return(builder.ToString());
}
private static void AppendObject(this HierarchicalStringBuilder builder, DiagnosticAnalyzer[] analyzers)
{
foreach (var analyzer in analyzers)
{
builder.AppendLine("Analyzer: {0}", analyzer.GetType().Name);
}
}
// ControlFlowGraph/Operation
private static void AppendProperty(this HierarchicalStringBuilder builder, string name, IOperation?operation)
{
if (operation == null)
{
return;
}
builder.AppendLine("{0}: Kind={1}", name, operation.Kind).AppendText(operation.Syntax);
}
private static void AppendObject(this HierarchicalStringBuilder builder, ModuleArchNode module)
{
using var scope = builder.AppendSection("Module: {0}", module.Name);
foreach (var @namespace in module.Namespaces)
{
builder.AppendObject(@namespace);
}
}
private static void AppendObject(this HierarchicalStringBuilder builder, NamespaceArchNode @namespace)
{
using var scope = builder.AppendSection("Namespace: {0}", @namespace.Name);
foreach (var group in @namespace.Groups)
{
builder.AppendObject(group);
}
}
// ControlFlowGraph/ControlFlowBranch
private static void AppendProperty(this HierarchicalStringBuilder builder, string name, ControlFlowBranch?branch)
{
if (branch == null)
{
return;
}
builder.AppendLine("{0}: Semantics={1}, Destination={2}", name, branch.Semantics, branch.Destination?.Ordinal);
}
private static void AppendObject(this HierarchicalStringBuilder builder, ProjectArchNode project)
{
using (builder.AppendTitle("Project: {0}", project.Name)) {
foreach (var module in project.Modules)
{
builder.AppendObject(module);
}
}
}
private static void AppendItem(this HierarchicalStringBuilder builder, DependenciesAnalysis.Reference reference)
{
builder.AppendItem("{0} ({1})", reference.Syntax, reference.Symbol?.Kind);
//if (reference.TypeSymbols.Any()) {
// builder.AppendItem( "{0} ({1}): {2}", reference.Syntax, reference.Symbol?.Kind, reference.TypeSymbols.Join() );
//} else {
// builder.AppendItem( "{0} ({1})", reference.Syntax, reference.Symbol?.Kind );
//}
}
// DependenciesAnalysis
public static string GetDisplayString(SyntaxNode syntax, DependenciesAnalysis analysis)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Dependencies analysis:")) {
builder.AppendHierarchy(syntax, analysis.References);
}
return(builder.ToString());
}
private static void AppendObject(this HierarchicalStringBuilder builder, GroupArchNode group)
{
if (!group.IsDefault)
{
builder.AppendLineWithPrefix("| - ", group.Name);
}
foreach (var type in group.Types)
{
builder.AppendLineWithPrefix("| ", type.Name);
}
}
// Analysis
public static string GetMessage(Compilation compilation, DiagnosticAnalyzer[] analyzers, Diagnostic[] diagnostics)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Analysis result:")) {
builder.AppendObject(compilation);
builder.AppendObject(analyzers);
builder.AppendObject(diagnostics);
}
return(builder.ToString());
}
// ControlFlowGraph/ControlFlowRegion
private static void AppendProperty(this HierarchicalStringBuilder builder, string name, ControlFlowRegion region)
{
using (builder.AppendSection("{0}: Kind={1}", name, region.Kind)) {
builder.AppendLine("Capture ids: {0}", region.CaptureIds.Join());
builder.AppendLine("Locals: {0}", region.Locals.Join());
builder.AppendLine("Local functions: {0}", region.LocalFunctions.Join());
foreach (var nestedRegion in region.NestedRegions)
{
builder.AppendProperty("Nested region", nestedRegion);
}
}
}
// ControlFlowGraph/BasicBlock
private static void AppendProperty(this HierarchicalStringBuilder builder, string name, BasicBlock block)
{
using (builder.AppendSection("{0}: Ordinal={1}, Kind={2}, Condition={3}, IsReachable={4}", name, block.Ordinal, block.Kind, block.ConditionKind, block.IsReachable)) {
builder.AppendProperty("Fall through successor", block.FallThroughSuccessor);
builder.AppendProperty("Conditional successor", block.ConditionalSuccessor);
builder.AppendProperty("Branch operation", block.BranchValue);
foreach (var operation in block.Operations)
{
builder.AppendProperty("Operation", operation);
}
}
}
private static IDisposable AppendSection(this HierarchicalStringBuilder builder, SyntaxNode scope)
{
var identifiers = (scope as MemberDeclarationSyntax)?.GetIdentifiers();
if (identifiers != null)
{
return(builder.AppendSection("{0}: {1}", scope.Kind(), identifiers.Join()));
}
else
{
return(builder.AppendSection("{0}", scope.Kind()));
}
}
// Generation
public static string GetMessage(ISourceGenerator generator, Compilation compilation, GeneratedSourceResult[] sources, Diagnostic[] diagnostics, Exception?exception)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Generation result:")) {
builder.AppendLine("Generator: {0}", generator.GetType().Name);
builder.AppendObject(compilation);
builder.AppendObject(diagnostics);
builder.AppendObject(exception);
builder.AppendObject(sources);
}
return(builder.ToString());
}
private static void AppendObject(this HierarchicalStringBuilder builder, Diagnostic[] diagnostics)
{
foreach (var diagnostic in diagnostics)
{
if (diagnostic.Location.IsInSource)
{
var location = diagnostic.Location;
builder.AppendLine("Diagnostic: {0}, {1} ({2} {3})", diagnostic.Id, diagnostic.GetMessage(), location.SourceTree.FilePath, location.SourceSpan);
}
else
{
builder.AppendLine("Diagnostic: {0}, {1}", diagnostic.Id, diagnostic.GetMessage());
}
}
}
// ControlFlowAnalysis
public static string GetDisplayString(BlockSyntax syntax, ControlFlowAnalysis analysis)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Control flow analysis: {0}", syntax.Parent !.Kind())) {
builder.AppendLine("Start point is reachable: {0}", analysis.StartPointIsReachable);
builder.AppendLine("End point is reachable: {0}", analysis.EndPointIsReachable);
builder.AppendLine("Entry points: {0}", analysis.EntryPoints.Join());
builder.AppendLine("Exit points: {0}", analysis.ExitPoints.Join());
builder.AppendLine("Return statements: {0}", analysis.ReturnStatements.Join());
}
return(builder.ToString());
}
// ControlFlowGraph
public static string GetDisplayString(ControlFlowGraph graph)
{
var builder = new HierarchicalStringBuilder();
using (builder.AppendTitle("Control flow graph:")) {
builder.AppendProperty("Original operation", graph.OriginalOperation);
builder.AppendSeparator();
builder.AppendProperty("Root region", graph.Root);
builder.AppendSeparator();
foreach (var block in graph.Blocks)
{
builder.AppendProperty("Block", block);
builder.AppendSeparator();
}
}
return(builder.ToString());
}
private static void AppendHierarchy(this HierarchicalStringBuilder builder, SyntaxNode scope, ImmutableArray <DependenciesAnalysis.Reference> references)
{
using (builder.AppendSection(scope)) {
if (scope is StatementSyntax && scope.Parent?.Parent is MethodDeclarationSyntax)
{
builder.AppendText(scope.ToString());
}
foreach (var reference in references.Where(i => i.GetScope() == scope))
{
builder.AppendItem(reference);
}
foreach (var child in scope.ChildNodes().Where(IsScope))
{
// This loop enters into only direct children scopes, so it may not come to some scopes
builder.AppendHierarchy(child, references);
}
}
}
// Helpers/HierarchicalStringBuilder
private static void AppendText(this HierarchicalStringBuilder builder, SyntaxNode syntax)
{
var lines = syntax.WithoutTrivia().GetText().Lines.Select(i => i.ToString());
builder.WithIndent().AppendText(lines);
}
// Helpers/AppendText
private static void AppendText(this HierarchicalStringBuilder builder, SourceText text)
{
var lines = text.Lines.Select(i => i.ToString());
builder.WithIndent().AppendText(lines);
}
// Helpers/AppendObject
private static void AppendObject(this HierarchicalStringBuilder builder, Compilation compilation)
{
builder.AppendLine("Compilation: {0} ({1})", compilation.AssemblyName, compilation.SyntaxTrees.Join(i => Path.GetFileName(i.FilePath)));
}
