IEnumerable <INamedTypeSymbol> FindNearestTupleConstructionWithInferrableType(SyntaxNode root, SemanticModel semanticModel, int position, SignatureHelpTriggerInfo triggerInfo,
ITypeInferenceService typeInferrer, ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken, out ExpressionSyntax targetExpression)
{
// Walk upward through TupleExpressionSyntax/ParenthsizedExpressionSyntax looking for a
// place where we can infer a tuple type.
TupleExpressionSyntax tupleExpression = null;
ParenthesizedExpressionSyntax parenthesizedExpression = null;
while (TryGetTupleExpression(triggerInfo.TriggerReason, root, position, syntaxFacts, cancellationToken, out tupleExpression) ||
TryGetParenthesizedExpression(triggerInfo.TriggerReason, root, position, syntaxFacts, cancellationToken, out parenthesizedExpression))
{
targetExpression = (ExpressionSyntax)tupleExpression ?? parenthesizedExpression;
var inferredTypes = typeInferrer.InferTypes(semanticModel, targetExpression.SpanStart, cancellationToken);
var tupleTypes = inferredTypes.Where(t => t.IsTupleType).OfType <INamedTypeSymbol>().ToList();
if (tupleTypes.Any())
{
return(tupleTypes);
}
position = targetExpression.GetFirstToken().SpanStart;
}
targetExpression = null;
return(null);
}
public override Ust VisitTupleExpression(TupleExpressionSyntax node)
{
var result = new TupleCreateExpression()
{
TextSpan = node.GetTextSpan(),
Initializers = new List <Expression>()
};
for (int i = 0; i < node.Arguments.Count; i++)
{
var arg = node.Arguments[i];
var assignment = new AssignmentExpression
{
Left = new IdToken($"Item{i + 1}", arg.GetTextSpan()),
Right = (Expression)VisitAndReturnNullIfError(arg.Expression),
TextSpan = arg.GetTextSpan()
};
result.Initializers.Add(assignment);
if (arg.NameColon != null)
{
result.Initializers.Add(new AssignmentExpression
{
Left = (IdToken)VisitAndReturnNullIfError(arg.NameColon.Name),
Right = (Expression)VisitAndReturnNullIfError(arg.Expression),
TextSpan = assignment.TextSpan
});
}
}
return(result);
}
private Doc PrintTupleExpressionSyntax(TupleExpressionSyntax node) =>
Group(
PrintArgumentListLikeSyntax(
node.OpenParenToken,
node.Arguments,
node.CloseParenToken
)
);
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
foreach (ArgumentSyntax argument in node.Arguments)
{
argument.Accept(this);
}
base.VisitTupleExpression(node);
}
public override Evaluation VisitTupleExpression(TupleExpressionSyntax node)
{
foreach (ArgumentSyntax argument in node.Arguments)
{
argument.Accept <Evaluation>(this);
}
return(base.VisitTupleExpression(node));
}
public static CodeAction ChangeTypeToVar(
Document document,
TupleExpressionSyntax tupleExpression,
string title = null,
string equivalenceKey = null)
{
return(CodeAction.Create(
title ?? "Change type to 'var'",
ct => DocumentRefactorings.ChangeTypeToVarAsync(document, tupleExpression, ct),
equivalenceKey));
}
public static Task <Document> FixListAsync(
Document document,
TupleExpressionSyntax tupleExpression,
ListFixMode fixMode = ListFixMode.Fix,
CancellationToken cancellationToken = default)
{
return(FixListAsync(
document,
tupleExpression,
tupleExpression.OpenParenToken,
tupleExpression.Arguments,
fixMode,
cancellationToken));
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (ArgumentSyntax argument in node.Arguments)
{
argument.Accept(this);
}
base.VisitTupleExpression(node);
PostVisit(node);
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
_TupleValues = new Stack <decimal>();
base.VisitTupleExpression(node);
if (_TupleValues.Count != 2)
{
Errors.Add(RateRulesErrors.MissingArgument);
}
else
{
var ask = _TupleValues.Pop();
var bid = _TupleValues.Pop();
Values.Push(new BidAsk(bid, ask));
}
_TupleValues = null;
}
public static Task <Document> ChangeTypeAsync(
Document document,
TypeSyntax type,
ITypeSymbol typeSymbol,
CancellationToken cancellationToken = default)
{
if (type.IsVar &&
type.Parent is DeclarationExpressionSyntax declarationExpression &&
declarationExpression.Designation.IsKind(SyntaxKind.ParenthesizedVariableDesignation))
{
#if DEBUG
SyntaxNode parent = declarationExpression.Parent;
switch (parent.Kind())
{
case SyntaxKind.SimpleAssignmentExpression:
{
var assignmentExpression = (AssignmentExpressionSyntax)parent;
Debug.Assert(object.ReferenceEquals(assignmentExpression.Left, declarationExpression));
break;
}
case SyntaxKind.ForEachVariableStatement:
{
var forEachStatement = (ForEachVariableStatementSyntax)parent;
Debug.Assert(object.ReferenceEquals(forEachStatement.Variable, declarationExpression));
break;
}
default:
{
SyntaxDebug.Fail(parent);
break;
}
}
#endif
TupleExpressionSyntax tupleExpression = CreateTupleExpression(typeSymbol)
.WithTriviaFrom(declarationExpression);
return(document.ReplaceNodeAsync(declarationExpression, tupleExpression, cancellationToken));
}
TypeSyntax newType = ChangeType(type, typeSymbol);
return(document.ReplaceNodeAsync(type, newType, cancellationToken));
}
private bool GetOuterMostTupleExpressionInSpan(SyntaxNode root, int position,
ISyntaxFactsService syntaxFacts, TextSpan currentSpan, CancellationToken cancellationToken, out TupleExpressionSyntax result)
{
result = null;
while (TryGetTupleExpression(SignatureHelpTriggerReason.InvokeSignatureHelpCommand,
root, position, syntaxFacts, cancellationToken, out var expression))
{
if (!currentSpan.Contains(expression.Span))
{
break;
}
result = expression;
position = expression.SpanStart;
}
return result != null;
}
public static Task <Document> ChangeTypeToVarAsync(
Document document,
TupleExpressionSyntax tupleExpression,
CancellationToken cancellationToken = default)
{
SeparatedSyntaxList <VariableDesignationSyntax> variables = tupleExpression.Arguments
.Select(f => f.Expression)
.Cast <DeclarationExpressionSyntax>()
.Select(f => f.Designation)
.ToSeparatedSyntaxList();
DeclarationExpressionSyntax declarationExpression = DeclarationExpression(
VarType(),
ParenthesizedVariableDesignation(variables))
.WithTriviaFrom(tupleExpression)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(tupleExpression, declarationExpression, cancellationToken));
}
private bool GetOuterMostTupleExpressionInSpan(SyntaxNode root, int position,
ISyntaxFactsService syntaxFacts, TextSpan currentSpan, CancellationToken cancellationToken, out TupleExpressionSyntax result)
{
result = null;
while (TryGetTupleExpression(SignatureHelpTriggerReason.InvokeSignatureHelpCommand,
root, position, syntaxFacts, cancellationToken, out var expression))
{
if (!currentSpan.Contains(expression.Span))
{
break;
}
result = expression;
position = expression.SpanStart;
}
return(result != null);
}
private bool TryGetTupleExpression(SignatureHelpTriggerReason triggerReason, SyntaxNode root, int position,
ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken, out TupleExpressionSyntax tupleExpression)
{
return(CommonSignatureHelpUtilities.TryGetSyntax(root, position, syntaxFacts, triggerReason, IsTupleExpressionTriggerToken,
IsTupleArgumentListToken, cancellationToken, out tupleExpression));
}
private static bool IsTupleArgumentListToken(TupleExpressionSyntax tupleExpression, SyntaxToken token)
{
return(tupleExpression.Arguments.FullSpan.Contains(token.SpanStart) &&
token != tupleExpression.CloseParenToken);
}
private static bool IsTupleArgumentListToken(TupleExpressionSyntax tupleExpression, SyntaxToken token)
{
return tupleExpression.Arguments.FullSpan.Contains(token.SpanStart) &&
token != tupleExpression.CloseParenToken;
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
}
public INamedTypeSymbol?ToSymbol(TupleExpressionSyntax node) => Model.GetDeclaredSymbol(node, CancellationToken);
private bool TryGetTupleExpression(SignatureHelpTriggerReason triggerReason, SyntaxNode root, int position,
ISyntaxFactsService syntaxFacts, CancellationToken cancellationToken, out TupleExpressionSyntax tupleExpression)
{
return CommonSignatureHelpUtilities.TryGetSyntax(root, position, syntaxFacts, triggerReason, IsTupleExpressionTriggerToken,
IsTupleArgumentListToken, cancellationToken, out tupleExpression);
}
public TameTupleExpressionSyntax(TupleExpressionSyntax node)
{
Node = node;
AddChildren();
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
LogUnsupportedSyntax(node);
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
this.VisitExpression(node);
}
private ITypeSymbol GetTupleType(
TupleExpressionSyntax tuple)
{
if (!TryGetTupleTypesAndNames(tuple.Arguments, out var elementTypes, out var elementNames))
{
return null;
}
return Compilation.CreateTupleTypeSymbol(elementTypes, elementNames);
}
private void AddTypeAndName(
TupleExpressionSyntax tuple,
ArrayBuilder<ITypeSymbol> elementTypesBuilder,
ArrayBuilder<string> elementNamesBuilder)
{
var tupleType = GetTupleType(tuple);
elementTypesBuilder.Add(tupleType);
elementNamesBuilder.Add(null);
}
/// <inheritdoc />
public override Expression VisitTupleExpression(TupleExpressionSyntax node)
{
return(Expressive.Tuple(
node.Arguments.Select(x => (ParameterExpression)x.Expression.Accept(this))
));
}
public override void VisitTupleExpression(TupleExpressionSyntax node)
{
throw new NotImplementedException();
}
public static Doc Print(TupleExpressionSyntax node) =>
Doc.Group(
ArgumentListLike.Print(node.OpenParenToken, node.Arguments, node.CloseParenToken)
);
// // Summary: // Called when the visitor visits a TupleExpressionSyntax node. public virtual void VisitTupleExpression(TupleExpressionSyntax node);
