|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Collections.Generic;
using System.Text;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Roslyn.Utilities;
namespace Microsoft.CodeAnalysis.CSharp
{
internal abstract partial class BoundNode
{
#if DEBUG
/// <summary>
/// Gives an approximate printout of a bound node as C# code.
/// </summary>
internal string DumpSource()
{
int indentSize = 4;
var builder = new StringBuilder();
appendSourceCore(this, indent: 0, tempIdentifiers: new Dictionary<SynthesizedLocal, int>());
return builder.ToString();
void appendSourceCore(BoundNode node, int indent, Dictionary<SynthesizedLocal, int> tempIdentifiers)
{
switch (node)
{
case BoundTryStatement tryStatement:
{
appendLine("try");
appendSource(tryStatement.TryBlock);
var catchBlocks = tryStatement.CatchBlocks;
if (catchBlocks != null)
{
foreach (var catchBlock in catchBlocks)
{
append("catch (");
append(catchBlock.ExceptionTypeOpt?.Name);
append(" ");
appendSource(catchBlock.ExceptionSourceOpt);
append(")");
if (catchBlock.ExceptionFilterOpt is { } exceptionFilter)
{
if (catchBlock.ExceptionFilterPrologueOpt is { } exceptionFilterPrologue)
{
appendLine("");
appendLine("{");
appendSource(exceptionFilterPrologue);
appendLine("}");
}
else
{
append(" ");
}
append("when (");
appendSource(exceptionFilter);
append(")");
}
appendLine("");
appendSource(catchBlock.Body);
}
}
var finallyBlock = tryStatement.FinallyBlockOpt;
if (finallyBlock != null)
{
appendLine("finally");
appendSource(finallyBlock);
}
break;
}
case BoundThrowStatement throwStatement:
{
append("throw ");
if (throwStatement.ExpressionOpt != null)
{
appendSource(throwStatement.ExpressionOpt);
}
appendLine(";");
break;
}
case BoundBlock block:
{
var statements = block.Statements;
if (statements.Length == 1 && block.Locals.IsEmpty)
{
appendSource(statements[0]);
break;
}
appendLine("{");
foreach (var local in block.Locals)
{
if (local is SynthesizedLocal synthesized)
{
appendLine($"{local.TypeWithAnnotations.ToDisplayString()} {name(synthesized)};");
}
else
{
appendLine($"({local.GetDebuggerDisplay()});");
}
}
foreach (var statement in statements)
{
appendSource(statement);
}
appendLine("}");
break;
}
case BoundStateMachineScope stateMachineScope:
{
appendSource(stateMachineScope.Statement);
break;
}
case BoundSequencePoint seqPoint:
{
var statement = seqPoint.StatementOpt;
if (statement != null)
{
appendSource(statement);
}
break;
}
case BoundSequencePointExpression seqPoint:
{
var expression = seqPoint.Expression;
appendSource(expression);
break;
}
case BoundSequencePointWithSpan seqPoint:
{
var statement = seqPoint.StatementOpt;
if (statement != null)
{
appendSource(statement);
}
break;
}
case BoundYieldReturnStatement yieldStatement:
{
append("yield return ");
appendSource(yieldStatement.Expression);
appendLine(";");
break;
}
case BoundReturnStatement returnStatement:
{
append("return");
var value = returnStatement.ExpressionOpt;
if (value != null)
{
append(" ");
appendSource(value);
}
appendLine(";");
break;
}
case BoundGotoStatement gotoStatement:
{
append("goto ");
append(gotoStatement.Label.ToString());
appendLine(";");
break;
}
case BoundConditionalGoto gotoStatement:
{
append("if (");
append(gotoStatement.JumpIfTrue ? "" : "!");
appendSource(gotoStatement.Condition);
append(") ");
append("goto ");
append(gotoStatement.Label.ToString());
appendLine(";");
break;
}
case BoundLabelStatement label:
{
append(label.Label.ToString());
appendLine(": ;");
break;
}
case BoundTypeExpression type:
{
append(type.Type.Name);
break;
}
case BoundLocal local:
{
var symbol = local.LocalSymbol;
appendLocal(symbol);
break;
}
case BoundNoOpStatement noop:
{
break;
}
case BoundExpressionStatement expressionStatement:
{
appendSource(expressionStatement.Expression);
appendLine(";");
break;
}
case BoundAwaitExpression awaitExpression:
{
append("await ");
appendSource(awaitExpression.Expression);
break;
}
case BoundCall call:
{
var receiver = call.ReceiverOpt;
if (receiver != null)
{
appendSource(receiver);
append(".");
}
append(call.Method.Name);
append("(");
bool first = true;
foreach (var argument in call.Arguments)
{
if (!first)
{
append(", ");
}
first = false;
appendSource(argument);
}
append(")");
break;
}
case BoundLiteral literal:
{
ConstantValue? constantValueOpt = literal.ConstantValueOpt;
appendConstantValue(constantValueOpt);
break;
}
case BoundAssignmentOperator assignment:
{
appendSource(assignment.Left);
append(" = ");
appendSource(assignment.Right);
break;
}
case BoundThisReference thisReference:
{
append("this");
break;
}
case BoundFieldAccess fieldAccess:
{
var receiver = fieldAccess.ReceiverOpt;
if (receiver != null)
{
appendSource(receiver);
append(".");
}
append(fieldAccess.FieldSymbol.Name);
break;
}
case BoundSwitchStatement switchStatement:
{
append("switch (");
appendSource(switchStatement.Expression);
appendLine(")");
appendLine("{");
foreach (BoundSwitchSection section in switchStatement.SwitchSections)
{
foreach (var label in section.SwitchLabels)
{
append("case ");
appendSource(label);
appendLine(":");
}
incrementIndent();
foreach (var statement in section.Statements)
{
appendSource(statement);
}
appendLine("break;");
decrementIndent();
}
appendLine("}");
break;
}
case BoundSwitchLabel label:
{
appendSource(label.Pattern);
break;
}
case BoundUnaryOperator unary:
{
append($" {unary.OperatorKind.ToString()} ");
appendSource(unary.Operand);
break;
}
case BoundConversion conversion:
{
append($" {conversion.Conversion} ");
appendSource(conversion.Operand);
break;
}
case BoundStatementList list:
{
foreach (var statement in list.Statements)
{
appendSource(statement);
}
break;
}
case BoundSequence sequence:
{
append("{ ");
foreach (var effect in sequence.SideEffects)
{
appendSource(effect);
append("; ");
}
appendSource(sequence.Value);
append(" }");
break;
}
case BoundDefaultLiteral _:
case BoundDefaultExpression _:
{
append("default");
break;
}
case BoundBinaryOperator binary:
{
appendSource(binary.Left);
append(" ");
append(binary.OperatorKind.ToString());
append(" ");
appendSource(binary.Right);
break;
}
case BoundBinaryPattern binaryPattern:
{
append("(");
appendSource(binaryPattern.Left);
append(binaryPattern.Disjunction ? " or " : " and ");
appendSource(binaryPattern.Right);
append(")");
break;
}
case BoundConstantPattern constantPattern:
{
appendConstantValue(constantPattern.ConstantValue);
break;
}
case BoundNegatedPattern negatedPattern:
{
append("(not ");
appendSource(negatedPattern.Negated);
append(")");
break;
}
case BoundListPattern listPattern:
{
append("[");
for (int i = 0; i < listPattern.Subpatterns.Length; i++)
{
if (i != 0) append(", ");
appendSource(listPattern.Subpatterns[i]);
}
append("]");
break;
}
case BoundSlicePattern slicePattern:
{
append("..");
if (slicePattern.Pattern is not null)
{
appendSource(slicePattern.Pattern);
}
break;
}
case BoundDiscardPattern:
{
append("_");
break;
}
case BoundTypePattern typePattern:
{
append(typePattern.DeclaredType.Type.ToString());
break;
}
case BoundRecursivePattern recursivePattern:
{
if (recursivePattern.DeclaredType is { } declaredType)
{
append(declaredType.Type.Name);
append(" ");
}
if (recursivePattern.Deconstruction is { IsDefault: false } deconstruction)
{
append("(");
for (int i = 0; i < deconstruction.Length; i++)
{
if (i != 0) append(", ");
appendSource(deconstruction[i].Pattern);
}
append(")");
}
if (recursivePattern.Properties is { IsDefault: false } properties)
{
append("{");
for (int i = 0; i < properties.Length; i++)
{
if (i != 0) append(", ");
BoundPropertySubpattern property = properties[i];
append(property.Member?.Symbol?.Name);
append(": ");
appendSource(property.Pattern);
}
append("}");
}
break;
}
case BoundDeclarationPattern declarationPattern:
{
if (declarationPattern.IsVar)
{
append("var ");
}
else
{
append(declarationPattern.DeclaredType.Type.Name);
append(" ");
}
append(declarationPattern.Variable?.Name);
break;
}
case BoundITuplePattern ituplePattern:
{
append("(");
for (int i = 0; i < ituplePattern.Subpatterns.Length; i++)
{
if (i != 0) append(", ");
appendSource(ituplePattern.Subpatterns[i].Pattern);
}
append(")");
break;
}
case BoundRelationalPattern relationalPattern:
{
string relation = (relationalPattern.Relation & BinaryOperatorKind.OpMask) switch
{
BinaryOperatorKind.GreaterThan => ">",
BinaryOperatorKind.GreaterThanOrEqual => ">=",
BinaryOperatorKind.LessThan => "<",
BinaryOperatorKind.LessThanOrEqual => "<=",
_ => relationalPattern.Relation.ToString()
};
append(relation);
append(" ");
appendConstantValue(relationalPattern.ConstantValue);
break;
}
default:
appendLine(node.Kind.ToString());
break;
}
void appendSource(BoundNode? n)
{
if (n is null)
{
append("NULL");
}
else
{
appendSourceCore(n, indent, tempIdentifiers);
}
}
void append(string? s)
{
builder.Append(s);
}
void incrementIndent()
{
indent += indentSize;
builder.Append(' ', indentSize);
}
void decrementIndent()
{
indent -= indentSize;
builder.Remove(builder.Length - indentSize, indentSize);
}
void appendLine(string s)
{
if (s == "{")
{
indent += indentSize;
builder.AppendLine(s);
builder.Append(' ', indent);
}
else if (s == "}")
{
builder.Remove(builder.Length - indentSize, indentSize);
builder.AppendLine(s);
indent -= indentSize;
builder.Append(' ', indent);
}
else
{
builder.AppendLine(s);
builder.Append(' ', indent);
}
}
string name(SynthesizedLocal local)
{
if (!tempIdentifiers.TryGetValue(local, out int identifier))
{
identifier = tempIdentifiers.Count + 1;
tempIdentifiers.Add(local, identifier);
}
return "temp" + identifier.ToString();
}
void appendLocal(LocalSymbol symbol)
{
if (symbol is SynthesizedLocal synthesized)
{
append(name(synthesized));
}
else
{
append($"({symbol.GetDebuggerDisplay()})");
}
}
void appendConstantValue(ConstantValue? constantValueOpt)
{
var value = constantValueOpt?.Value?.ToString();
if (value is null)
{
append("null");
return;
}
switch (constantValueOpt?.Discriminator)
{
case ConstantValueTypeDiscriminator.String:
append($@"""{value}""");
break;
default:
append(value);
break;
}
}
}
}
#endif
}
}
|