public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
Write("(");
bool first = true;
foreach (var v in node.Variables)
{
if (first)
{
first = false;
}
else
{
Write(", ");
}
if (v is SingleVariableDesignationSyntax single)
{
Write(single.Identifier.Text);
}
if (v is DiscardDesignationSyntax _)
{
Write("_");
}
}
Write(")");
}
public static string GetTupleName(ParenthesizedVariableDesignationSyntax node)
{
return(String.Join("", node.Variables.Select((v, i) => {
var sourceText1 = v.ToString();
return i > 0 ? UppercaseFirstLetter(sourceText1) : sourceText1;
})));
}
internal static async Task HandleDeclarationAsync(
Document document, SyntaxEditor editor,
SyntaxNode node, CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var declarationContext = node.Parent;
TypeSyntax typeSyntax = null;
ParenthesizedVariableDesignationSyntax parensDesignation = null;
if (declarationContext is VariableDeclarationSyntax varDecl)
{
typeSyntax = varDecl.Type;
}
else if (declarationContext is ForEachStatementSyntax forEach)
{
typeSyntax = forEach.Type;
}
else if (declarationContext is DeclarationExpressionSyntax declarationExpression)
{
typeSyntax = declarationExpression.Type;
if (declarationExpression.Designation.IsKind(SyntaxKind.ParenthesizedVariableDesignation))
{
parensDesignation = (ParenthesizedVariableDesignationSyntax)declarationExpression.Designation;
}
}
else
{
Contract.Fail($"unhandled kind {declarationContext.Kind().ToString()}");
}
if (parensDesignation is null)
{
var typeSymbol = semanticModel.GetTypeInfo(typeSyntax).ConvertedType;
// We're going to be passed through the simplifier. Tell it to not just convert
// this back to var (as that would defeat the purpose of this refactoring entirely).
var typeName = typeSymbol.GenerateTypeSyntax(allowVar: false)
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia());
Debug.Assert(!typeName.ContainsDiagnostics, "Explicit type replacement likely introduced an error in code");
editor.ReplaceNode(node, typeName);
}
else
{
var tupleTypeSymbol = semanticModel.GetTypeInfo(typeSyntax.Parent).ConvertedType;
var leadingTrivia = node.GetLeadingTrivia()
.Concat(parensDesignation.GetAllPrecedingTriviaToPreviousToken().Where(t => !t.IsWhitespace()).Select(t => t.WithoutAnnotations(SyntaxAnnotation.ElasticAnnotation)));
var tupleDeclaration = GenerateTupleDeclaration(tupleTypeSymbol, parensDesignation).WithLeadingTrivia(leadingTrivia);
editor.ReplaceNode(declarationContext, tupleDeclaration);
}
}
public override Evaluation VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
foreach (VariableDesignationSyntax variable in node.Variables)
{
variable.Accept <Evaluation>(this);
}
return(base.VisitParenthesizedVariableDesignation(node));
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
foreach (VariableDesignationSyntax variable in node.Variables)
{
variable.Accept(this);
}
base.VisitParenthesizedVariableDesignation(node);
}
public static Doc Print(ParenthesizedVariableDesignationSyntax node)
{
return(Doc.Group(
Token.Print(node.OpenParenToken),
Doc.Indent(
Doc.SoftLine,
SeparatedSyntaxList.Print(node.Variables, Node.Print, Doc.Line),
Doc.SoftLine
),
Token.Print(node.CloseParenToken)
));
}
private static ExpressionSyntax GenerateTupleDeclaration(
ITypeSymbol typeSymbol,
ParenthesizedVariableDesignationSyntax parensDesignation
)
{
Debug.Assert(typeSymbol.IsTupleType);
var elements = ((INamedTypeSymbol)typeSymbol).TupleElements;
Debug.Assert(elements.Length == parensDesignation.Variables.Count);
using var builderDisposer = ArrayBuilder <SyntaxNode> .GetInstance(
elements.Length,
out var builder
);
for (var i = 0; i < elements.Length; i++)
{
var designation = parensDesignation.Variables[i];
var type = elements[i].Type;
ExpressionSyntax newDeclaration;
switch (designation.Kind())
{
case SyntaxKind.SingleVariableDesignation:
case SyntaxKind.DiscardDesignation:
var typeName = type.GenerateTypeSyntax(allowVar: false);
newDeclaration = SyntaxFactory.DeclarationExpression(typeName, designation);
break;
case SyntaxKind.ParenthesizedVariableDesignation:
newDeclaration = GenerateTupleDeclaration(
type,
(ParenthesizedVariableDesignationSyntax)designation
);
break;
default:
throw ExceptionUtilities.UnexpectedValue(designation.Kind());
}
newDeclaration = newDeclaration
.WithLeadingTrivia(designation.GetAllPrecedingTriviaToPreviousToken())
.WithTrailingTrivia(designation.GetTrailingTrivia());
builder.Add(SyntaxFactory.Argument(newDeclaration));
}
var separatorBuilder = ArrayBuilder <SyntaxToken> .GetInstance(
builder.Count - 1,
SyntaxFactory.Token(leading: default, SyntaxKind.CommaToken, trailing: default)
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (VariableDesignationSyntax variable in node.Variables)
{
variable.Accept(this);
}
base.VisitParenthesizedVariableDesignation(node);
PostVisit(node);
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
Write("(");
Delimit(node.Variables, v =>
{
if (v is SingleVariableDesignationSyntax single)
{
Write(single.Identifier.Text);
}
if (v is DiscardDesignationSyntax _)
{
Write("_");
}
});
Write(")");
}
private Doc PrintParenthesizedVariableDesignationSyntax(
ParenthesizedVariableDesignationSyntax node)
{
return(Group(
this.PrintSyntaxToken(node.OpenParenToken),
Indent(
SoftLine,
this.PrintSeparatedSyntaxList(
node.Variables,
this.Print,
Line
),
SoftLine
),
this.PrintSyntaxToken(node.CloseParenToken)
));
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
Write("(");
bool first = true;
foreach (SingleVariableDesignationSyntax v in node.Variables)
{
if (first)
{
first = false;
}
else
{
Write(", ");
}
Write(v.Identifier.Text);
}
Write(")");
}
public static Expression CreateParenthesized(Context cx, VarPatternSyntax varPattern, ParenthesizedVariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
var tuple = new Expression(
new ExpressionInfo(cx, null, cx.CreateLocation(varPattern.GetLocation()), ExprKind.TUPLE, parent, child, false, null),
shouldPopulate: false);
var elementTypes = new List <ITypeSymbol?>();
cx.Try(null, null, () =>
{
var child0 = 0;
foreach (var variable in designation.Variables)
{
Expression sub;
switch (variable)
{
case ParenthesizedVariableDesignationSyntax paren:
sub = CreateParenthesized(cx, varPattern, paren, tuple, child0++);
break;
case SingleVariableDesignationSyntax single:
if (cx.GetModel(variable).GetDeclaredSymbol(single) is ILocalSymbol local)
{
var decl = Create(cx, variable, local.GetAnnotatedType(), tuple, child0++);
var l = LocalVariable.Create(cx, local);
l.PopulateManual(decl, true);
sub = decl;
}
else
{
throw new InternalError(single, "Failed to access local variable");
}
break;
case DiscardDesignationSyntax discard:
sub = new Discard(cx, discard, tuple, child0++);
if (!sub.Type.HasValue || sub.Type.Value.Symbol is null)
{
// The type is only updated in memory, it will not be written to the trap file.
sub.SetType(cx.Compilation.GetSpecialType(SpecialType.System_Object));
}
break;
default:
var type = variable.GetType().ToString() ?? "null";
throw new InternalError(variable, $"Unhandled designation type {type}");
}
elementTypes.Add(sub.Type.HasValue && sub.Type.Value.Symbol?.Kind != SymbolKind.ErrorType
? sub.Type.Value.Symbol
: null);
}
});
INamedTypeSymbol?tupleType = null;
if (!elementTypes.Any(et => et is null))
{
tupleType = cx.Compilation.CreateTupleTypeSymbol(elementTypes.ToImmutableArray() !);
}
tuple.SetType(tupleType);
tuple.TryPopulate();
return(tuple);
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
throw new NotImplementedException();
}
/// <summary>
/// Create a tuple expression representing a parenthesized variable declaration.
/// That is, we consider `var (x, y) = ...` to be equivalent to `(var x, var y) = ...`.
/// </summary>
public static Expression CreateParenthesized(Context cx, DeclarationExpressionSyntax node, ParenthesizedVariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
var type = Entities.NullType.Create(cx); // Should ideally be a corresponding tuple type
var tuple = new Expression(new ExpressionInfo(cx, type, cx.Create(node.GetLocation()), ExprKind.TUPLE, parent, child, false, null));
cx.Try(null, null, () =>
{
var child0 = 0;
foreach (var variable in designation.Variables)
{
Create(cx, node, variable, tuple, child0++);
}
});
return(tuple);
}
/// <summary>
/// Create a tuple expression representing a parenthesized variable declaration.
/// That is, we consider `var (x, y) = ...` to be equivalent to `(var x, var y) = ...`.
/// </summary>
public static Expression CreateParenthesized(Context cx, DeclarationExpressionSyntax node, ParenthesizedVariableDesignationSyntax designation, IExpressionParentEntity parent, int child, INamedTypeSymbol?t)
{
var type = t is null ? (AnnotatedTypeSymbol?)null : new AnnotatedTypeSymbol(t, t.NullableAnnotation);
var tuple = new Expression(new ExpressionInfo(cx, type, cx.CreateLocation(node.GetLocation()), ExprKind.TUPLE, parent, child, false, null));
cx.Try(null, null, () =>
{
for (var child0 = 0; child0 < designation.Variables.Count; child0++)
{
Create(cx, node, designation.Variables[child0], tuple, child0, t?.TypeArguments[child0] as INamedTypeSymbol);
}
});
return(tuple);
}
public TameParenthesizedVariableDesignationSyntax(ParenthesizedVariableDesignationSyntax node)
{
Node = node;
AddChildren();
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
}
public override void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node)
{
Log(node, "Unsupported Syntax !");
}
public static Expression CreateParenthesized(Context cx, VarPatternSyntax varPattern, ParenthesizedVariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
var type = NullType.Create(cx); // Should ideally be a corresponding tuple type
var tuple = new Expression(new ExpressionInfo(cx, type, cx.Create(varPattern.GetLocation()), ExprKind.TUPLE, parent, child, false, null));
cx.Try(null, null, () =>
{
var child0 = 0;
foreach (var variable in designation.Variables)
{
switch (variable)
{
case ParenthesizedVariableDesignationSyntax paren:
CreateParenthesized(cx, varPattern, paren, tuple, child0++);
break;
case SingleVariableDesignationSyntax single:
if (cx.GetModel(variable).GetDeclaredSymbol(single) is ILocalSymbol local)
{
var decl = Create(cx, variable, Entities.Type.Create(cx, local.GetAnnotatedType()), true, tuple, child0++);
var id = single.Identifier;
var location = cx.Create(id.GetLocation());
LocalVariable.Create(cx, local, decl, true, location);
}
else
{
throw new InternalError(single, "Failed to access local variable");
}
break;
case DiscardDesignationSyntax discard:
new Discard(cx, discard, tuple, child0++);
break;
default:
throw new InternalError(variable, "Unhandled designation type");
}
}
});
return(tuple);
}
// // Summary: // Called when the visitor visits a ParenthesizedVariableDesignationSyntax node. public virtual void VisitParenthesizedVariableDesignation(ParenthesizedVariableDesignationSyntax node);
