public ChangeSignatureOptionsResult?GetChangeSignatureOptions(
Document document,
int positionForTypeBinding,
ISymbol symbol,
ParameterConfiguration parameters)
{
this.AssertIsForeground();
var viewModel = new ChangeSignatureDialogViewModel(
parameters,
symbol,
document,
positionForTypeBinding,
_classificationFormatMap,
_classificationTypeMap);
ChangeSignatureLogger.LogChangeSignatureDialogLaunched();
var dialog = new ChangeSignatureDialog(viewModel);
var result = dialog.ShowModal();
if (result.HasValue && result.Value)
{
ChangeSignatureLogger.LogChangeSignatureDialogCommitted();
var signatureChange = new SignatureChange(parameters, viewModel.GetParameterConfiguration());
signatureChange.LogTelemetry();
return(new ChangeSignatureOptionsResult(signatureChange, previewChanges: viewModel.PreviewChanges));
}
return(null);
}
private static SeparatedSyntaxList <AttributeArgumentSyntax> PermuteAttributeArgumentList(
Document document,
ISymbol declarationSymbol,
SeparatedSyntaxList <AttributeArgumentSyntax> arguments,
SignatureChange updatedSignature)
{
var newArguments = PermuteArguments(document, declarationSymbol, arguments.Select(a => UnifiedArgumentSyntax.Create(a)).ToList(), updatedSignature);
var numSeparatorsToSkip = arguments.Count - newArguments.Count;
return(SyntaxFactory.SeparatedList(newArguments.Select(a => (AttributeArgumentSyntax)(UnifiedArgumentSyntax)a), GetSeparators(arguments, numSeparatorsToSkip)));
}
private TextBox AddSignatureNoCopy(SignatureChange signatureChange, int textboxToReturnPageIndex = -1)
{
CurrentSignatures.Add(signatureChange);
var changes = new SignatureChanges();
changes.Added.Add(signatureChange);
UndoChangeList.Add(changes);
return(AddSignatureToPages(signatureChange, textboxToReturnPageIndex));
}
public void UpdateTransaction(TaskCard taskCard)
{
signatureChange = new FinancialPlanner.Common.JSONSerialization().DeserializeFromString <SignatureChange>(taskCard.TaskTransactionType.ToString());
DataBase.DBService.ExecuteCommandString(string.Format(UPDATE_QUERY,
taskCard.Id,
signatureChange.Arn,
signatureChange.Cid,
signatureChange.MemberName,
signatureChange.Amc,
signatureChange.FolioNumber,
signatureChange.SignatureChangeOf,
signatureChange.ModeOfExecution,
taskCard.Id), true);
}
private static SeparatedSyntaxList <AttributeArgumentSyntax> PermuteAttributeArgumentList(
Document document,
ISymbol declarationSymbol,
SeparatedSyntaxList <AttributeArgumentSyntax> arguments,
SignatureChange updatedSignature)
{
var newArguments = PermuteArguments(document, declarationSymbol, arguments.Select(a => UnifiedArgumentSyntax.Create(a)).ToList(), updatedSignature);
var numSeparatorsToSkip = arguments.Count - newArguments.Count;
// copy whitespace trivia from original position
var newArgumentsWithTrivia = TransferLeadingWhitespaceTrivia(
newArguments.Select(a => (AttributeArgumentSyntax)(UnifiedArgumentSyntax)a), arguments);
return(SyntaxFactory.SeparatedList(newArgumentsWithTrivia, GetSeparators(arguments, numSeparatorsToSkip)));
}
private SignatureChange converToBankchangeRequest(DataRow dr)
{
SignatureChange contactUpdate = new SignatureChange();
contactUpdate.Id = dr.Field <int>("ID");
contactUpdate.TaskId = dr.Field <int>("TaskId");
contactUpdate.Cid = dr.Field <int>("CID");
contactUpdate.Arn = dr.Field <int>("ARN");
contactUpdate.MemberName = dr.Field <string>("MemberName");
contactUpdate.Amc = dr.Field <int>("AMC");
contactUpdate.FolioNumber = dr.Field <string>("FolioNumber");
contactUpdate.SignatureChangeOf = dr.Field <string>("SignatureChangeOf");
contactUpdate.ModeOfExecution = dr.Field <string>("ModeOfExecution");
return(contactUpdate);
}
private TextBox AddSignatureToPages(SignatureChange signatureChange, int textboxToReturnPageIndex = -1)
{
TextBox textbox = null;
for (int i = 0; i < Pages.Count; i++)
{
TextBox tb = CreateSignatureTextBox(signatureChange.Text, new Thickness(signatureChange.X, signatureChange.Y, 0, 0), i + 1, Pages.Count);
Pages[i].AddUIElement(tb);
signatureChange.UIElements.Add((i, tb));
if (i == textboxToReturnPageIndex)
{
textbox = tb;
}
}
return(textbox);
}
/// <summary>
/// Add an editable TextBox to all pages of the document (returns specified textbox, for focusing)
/// </summary>
public TextBox InitialAddSignatureTb(double x, double y, int textboxToReturnPageIndex)
{
// match x and y coordinates to height/width of the content of the page
x = x - Padding.Left;
y = y - Padding.Top;
if (x < 0 || x > ContentWidth)
{
return(null);
}
if (y < 0 || y > ContentHeight)
{
return(null);
}
// approximately center textbox on coordinates
x -= 2;
y -= 8;
var bindableText = new BindableText();
var signatureChange = new SignatureChange(bindableText, x, y);
return(AddSignatureNoCopy(signatureChange, textboxToReturnPageIndex));
}
public object GetTransaction(int id)
{
try
{
Logger.LogInfo("Get: PanCard change request transaction process start");
signatureChange = new SignatureChange();
DataTable dtAppConfig = DataBase.DBService.ExecuteCommand(string.Format(SELECT_BY_ID, id));
foreach (DataRow dr in dtAppConfig.Rows)
{
signatureChange = converToBankchangeRequest(dr);
}
Logger.LogInfo("Get: Pancard change request transaction process completed.");
return(signatureChange);
}
catch (Exception ex)
{
StackTrace st = new StackTrace();
StackFrame sf = st.GetFrame(0);
MethodBase currentMethodName = sf.GetMethod();
LogDebug(currentMethodName.Name, ex);
return(null);
}
}
private List <XmlElementSyntax> VerifyAndPermuteParamNodes(IEnumerable <XmlElementSyntax> paramNodes, ISymbol declarationSymbol, SignatureChange updatedSignature)
{
// Only reorder if count and order match originally.
var originalParameters = updatedSignature.OriginalConfiguration.ToListOfParameters();
var reorderedParameters = updatedSignature.UpdatedConfiguration.ToListOfParameters();
var declaredParameters = declarationSymbol.GetParameters();
if (paramNodes.Count() != declaredParameters.Count())
{
return(null);
}
var dictionary = new Dictionary <string, XmlElementSyntax>();
int i = 0;
foreach (var paramNode in paramNodes)
{
var nameAttribute = paramNode.StartTag.Attributes.FirstOrDefault(a => a.Name.ToString().Equals("name", StringComparison.OrdinalIgnoreCase));
if (nameAttribute == null)
{
return(null);
}
var identifier = nameAttribute.DescendantNodes(descendIntoTrivia: true).OfType <IdentifierNameSyntax>().FirstOrDefault();
if (identifier == null || identifier.ToString() != declaredParameters.ElementAt(i).Name)
{
return(null);
}
dictionary.Add(originalParameters[i].Name.ToString(), paramNode);
i++;
}
// Everything lines up, so permute them.
var permutedParams = new List <XmlElementSyntax>();
foreach (var parameter in reorderedParameters)
{
permutedParams.Add(dictionary[parameter.Name]);
}
return(permutedParams);
}
private List <SyntaxTrivia> UpdateParamTagsInLeadingTrivia(CSharpSyntaxNode node, ISymbol declarationSymbol, SignatureChange updatedSignature)
{
if (!node.HasLeadingTrivia)
{
return(null);
}
var paramNodes = node
.DescendantNodes(descendIntoTrivia: true)
.OfType <XmlElementSyntax>()
.Where(e => e.StartTag.Name.ToString() == DocumentationCommentXmlNames.ParameterElementName);
var permutedParamNodes = VerifyAndPermuteParamNodes(paramNodes, declarationSymbol, updatedSignature);
if (permutedParamNodes == null)
{
return(null);
}
return(GetPermutedTrivia(node, permutedParamNodes));
}
private SeparatedSyntaxList <T> PermuteDeclaration <T>(SeparatedSyntaxList <T> list, SignatureChange updatedSignature) where T : SyntaxNode
{
var originalParameters = updatedSignature.OriginalConfiguration.ToListOfParameters();
var reorderedParameters = updatedSignature.UpdatedConfiguration.ToListOfParameters();
var newParameters = new List <T>();
foreach (var newParam in reorderedParameters)
{
var pos = originalParameters.IndexOf(newParam);
var param = list[pos];
newParameters.Add(param);
}
var numSeparatorsToSkip = originalParameters.Count - reorderedParameters.Count;
return(SyntaxFactory.SeparatedList(newParameters, GetSeparators(list, numSeparatorsToSkip)));
}
public override SyntaxNode ChangeSignature(
Document document,
ISymbol declarationSymbol,
SyntaxNode potentiallyUpdatedNode,
SyntaxNode originalNode,
SignatureChange signaturePermutation,
CancellationToken cancellationToken)
{
var updatedNode = potentiallyUpdatedNode as CSharpSyntaxNode;
// Update <param> tags.
if (updatedNode.IsKind(SyntaxKind.MethodDeclaration) ||
updatedNode.IsKind(SyntaxKind.ConstructorDeclaration) ||
updatedNode.IsKind(SyntaxKind.IndexerDeclaration) ||
updatedNode.IsKind(SyntaxKind.DelegateDeclaration))
{
var updatedLeadingTrivia = UpdateParamTagsInLeadingTrivia(updatedNode, declarationSymbol, signaturePermutation);
if (updatedLeadingTrivia != null)
{
updatedNode = updatedNode.WithLeadingTrivia(updatedLeadingTrivia);
}
}
// Update declarations parameter lists
if (updatedNode.IsKind(SyntaxKind.MethodDeclaration))
{
var method = updatedNode as MethodDeclarationSyntax;
var updatedParameters = PermuteDeclaration(method.ParameterList.Parameters, signaturePermutation);
return(method.WithParameterList(method.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.ConstructorDeclaration))
{
var constructor = updatedNode as ConstructorDeclarationSyntax;
var updatedParameters = PermuteDeclaration(constructor.ParameterList.Parameters, signaturePermutation);
return(constructor.WithParameterList(constructor.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.IndexerDeclaration))
{
var indexer = updatedNode as IndexerDeclarationSyntax;
var updatedParameters = PermuteDeclaration(indexer.ParameterList.Parameters, signaturePermutation);
return(indexer.WithParameterList(indexer.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.DelegateDeclaration))
{
var delegateDeclaration = updatedNode as DelegateDeclarationSyntax;
var updatedParameters = PermuteDeclaration(delegateDeclaration.ParameterList.Parameters, signaturePermutation);
return(delegateDeclaration.WithParameterList(delegateDeclaration.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.AnonymousMethodExpression))
{
var anonymousMethod = updatedNode as AnonymousMethodExpressionSyntax;
// Delegates may omit parameters in C#
if (anonymousMethod.ParameterList == null)
{
return(anonymousMethod);
}
var updatedParameters = PermuteDeclaration(anonymousMethod.ParameterList.Parameters, signaturePermutation);
return(anonymousMethod.WithParameterList(anonymousMethod.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.SimpleLambdaExpression))
{
var lambda = updatedNode as SimpleLambdaExpressionSyntax;
if (signaturePermutation.UpdatedConfiguration.ToListOfParameters().Any())
{
Debug.Assert(false, "Updating a simple lambda expression without removing its parameter");
}
else
{
// No parameters. Change to a parenthesized lambda expression
var emptyParameterList = SyntaxFactory.ParameterList()
.WithLeadingTrivia(lambda.Parameter.GetLeadingTrivia())
.WithTrailingTrivia(lambda.Parameter.GetTrailingTrivia());
return(SyntaxFactory.ParenthesizedLambdaExpression(lambda.AsyncKeyword, emptyParameterList, lambda.ArrowToken, lambda.Body));
}
}
if (updatedNode.IsKind(SyntaxKind.ParenthesizedLambdaExpression))
{
var lambda = updatedNode as ParenthesizedLambdaExpressionSyntax;
var updatedParameters = PermuteDeclaration(lambda.ParameterList.Parameters, signaturePermutation);
return(lambda.WithParameterList(lambda.ParameterList.WithParameters(updatedParameters)));
}
// Update reference site argument lists
if (updatedNode.IsKind(SyntaxKind.InvocationExpression))
{
var invocation = updatedNode as InvocationExpressionSyntax;
var semanticModel = document.GetSemanticModelAsync(cancellationToken).WaitAndGetResult(cancellationToken);
var symbolInfo = semanticModel.GetSymbolInfo(originalNode as InvocationExpressionSyntax, cancellationToken);
var methodSymbol = symbolInfo.Symbol as IMethodSymbol;
var isReducedExtensionMethod = false;
if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.ReducedExtension)
{
isReducedExtensionMethod = true;
}
var newArguments = PermuteArgumentList(document, declarationSymbol, invocation.ArgumentList.Arguments, signaturePermutation, isReducedExtensionMethod);
return(invocation.WithArgumentList(invocation.ArgumentList.WithArguments(newArguments).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.ObjectCreationExpression))
{
var objCreation = updatedNode as ObjectCreationExpressionSyntax;
var newArguments = PermuteArgumentList(document, declarationSymbol, objCreation.ArgumentList.Arguments, signaturePermutation);
return(objCreation.WithArgumentList(objCreation.ArgumentList.WithArguments(newArguments).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.ThisConstructorInitializer) ||
updatedNode.IsKind(SyntaxKind.BaseConstructorInitializer))
{
var objCreation = updatedNode as ConstructorInitializerSyntax;
var newArguments = PermuteArgumentList(document, declarationSymbol, objCreation.ArgumentList.Arguments, signaturePermutation);
return(objCreation.WithArgumentList(objCreation.ArgumentList.WithArguments(newArguments).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.ElementAccessExpression))
{
var elementAccess = updatedNode as ElementAccessExpressionSyntax;
var newArguments = PermuteArgumentList(document, declarationSymbol, elementAccess.ArgumentList.Arguments, signaturePermutation);
return(elementAccess.WithArgumentList(elementAccess.ArgumentList.WithArguments(newArguments).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
if (updatedNode.IsKind(SyntaxKind.Attribute))
{
var attribute = updatedNode as AttributeSyntax;
var newArguments = PermuteAttributeArgumentList(document, declarationSymbol, attribute.ArgumentList.Arguments, signaturePermutation);
return(attribute.WithArgumentList(attribute.ArgumentList.WithArguments(newArguments).WithAdditionalAnnotations(changeSignatureFormattingAnnotation)));
}
// Handle references in crefs
if (updatedNode.IsKind(SyntaxKind.NameMemberCref))
{
var nameMemberCref = updatedNode as NameMemberCrefSyntax;
if (nameMemberCref.Parameters == null ||
!nameMemberCref.Parameters.Parameters.Any())
{
return(nameMemberCref);
}
var newParameters = PermuteDeclaration(nameMemberCref.Parameters.Parameters, signaturePermutation);
var newCrefParameterList = nameMemberCref.Parameters.WithParameters(newParameters);
return(nameMemberCref.WithParameters(newCrefParameterList));
}
Debug.Assert(false, "Unknown reference location");
return(null);
}
public override async Task<SyntaxNode> ChangeSignatureAsync(
Document document,
ISymbol declarationSymbol,
SyntaxNode potentiallyUpdatedNode,
SyntaxNode originalNode,
SignatureChange signaturePermutation,
CancellationToken cancellationToken)
{
var updatedNode = potentiallyUpdatedNode as CSharpSyntaxNode;
// Update <param> tags.
if (updatedNode.IsKind(SyntaxKind.MethodDeclaration) ||
updatedNode.IsKind(SyntaxKind.ConstructorDeclaration) ||
updatedNode.IsKind(SyntaxKind.IndexerDeclaration) ||
updatedNode.IsKind(SyntaxKind.DelegateDeclaration))
{
var updatedLeadingTrivia = UpdateParamTagsInLeadingTrivia(document, updatedNode, declarationSymbol, signaturePermutation);
if (updatedLeadingTrivia != default && !updatedLeadingTrivia.IsEmpty)
{
updatedNode = updatedNode.WithLeadingTrivia(updatedLeadingTrivia);
}
}
// Update declarations parameter lists
if (updatedNode.IsKind(SyntaxKind.MethodDeclaration, out MethodDeclarationSyntax? method))
{
var updatedParameters = UpdateDeclaration(method.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return method.WithParameterList(method.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.LocalFunctionStatement, out LocalFunctionStatementSyntax? localFunction))
{
var updatedParameters = UpdateDeclaration(localFunction.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return localFunction.WithParameterList(localFunction.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.ConstructorDeclaration, out ConstructorDeclarationSyntax? constructor))
{
var updatedParameters = UpdateDeclaration(constructor.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return constructor.WithParameterList(constructor.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.IndexerDeclaration, out IndexerDeclarationSyntax? indexer))
{
var updatedParameters = UpdateDeclaration(indexer.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return indexer.WithParameterList(indexer.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.DelegateDeclaration, out DelegateDeclarationSyntax? delegateDeclaration))
{
var updatedParameters = UpdateDeclaration(delegateDeclaration.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return delegateDeclaration.WithParameterList(delegateDeclaration.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.AnonymousMethodExpression, out AnonymousMethodExpressionSyntax? anonymousMethod))
{
// Delegates may omit parameters in C#
if (anonymousMethod.ParameterList == null)
{
return anonymousMethod;
}
var updatedParameters = UpdateDeclaration(anonymousMethod.ParameterList.Parameters, signaturePermutation, CreateNewParameterSyntax);
return anonymousMethod.WithParameterList(anonymousMethod.ParameterList.WithParameters(updatedParameters).WithAdditionalAnnotations(changeSignatureFormattingAnnotation));
}
if (updatedNode.IsKind(SyntaxKind.SimpleLambdaExpression, out SimpleLambdaExpressionSyntax? lambda))
{
if (signaturePermutation.UpdatedConfiguration.ToListOfParameters().Any())
{
var updatedParameters = UpdateDeclaration(SeparatedList(new[] { lambda.Parameter }), signaturePermutation, CreateNewParameterSyntax);
return ParenthesizedLambdaExpression(
lambda.AsyncKeyword,
ParameterList(updatedParameters),
lambda.ArrowToken,
lambda.Body);
}
else
{
// No parameters. Change to a parenthesized lambda expression
var emptyParameterList = ParameterList()
.WithLeadingTrivia(lambda.Parameter.GetLeadingTrivia())
.WithTrailingTrivia(lambda.Parameter.GetTrailingTrivia());
return ParenthesizedLambdaExpression(lambda.AsyncKeyword, emptyParameterList, lambda.ArrowToken, lambda.Body);
}
}
if (updatedNode.IsKind(SyntaxKind.ParenthesizedLambdaExpression, out ParenthesizedLambdaExpressionSyntax? parenLambda))
{
var doNotSkipParameterType = parenLambda.ParameterList.Parameters.FirstOrDefault()?.Type != null;
var updatedParameters = UpdateDeclaration(
parenLambda.ParameterList.Parameters,
signaturePermutation,
p => CreateNewParameterSyntax(p, !doNotSkipParameterType));
return parenLambda.WithParameterList(parenLambda.ParameterList.WithParameters(updatedParameters));
}
// Update reference site argument lists
if (updatedNode.IsKind(SyntaxKind.InvocationExpression, out InvocationExpressionSyntax? invocation))
{
var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var symbolInfo = semanticModel.GetSymbolInfo((InvocationExpressionSyntax)originalNode, cancellationToken);
return invocation.WithArgumentList(
await UpdateArgumentListAsync(
declarationSymbol,
signaturePermutation,
invocation.ArgumentList,
symbolInfo.Symbol is IMethodSymbol { MethodKind: MethodKind.ReducedExtension },
private SeparatedSyntaxList <T> PermuteDeclaration <T>(SeparatedSyntaxList <T> list, SignatureChange updatedSignature) where T : SyntaxNode
{
var originalParameters = updatedSignature.OriginalConfiguration.ToListOfParameters();
var reorderedParameters = updatedSignature.UpdatedConfiguration.ToListOfParameters();
var newParameters = new List <T>();
for (var index = 0; index < reorderedParameters.Count; index++)
{
var newParam = reorderedParameters[index];
var pos = originalParameters.IndexOf(newParam);
var param = list[pos];
// copy whitespace trivia from original position
param = TransferLeadingWhitespaceTrivia(param, list[index]);
newParameters.Add(param);
}
var numSeparatorsToSkip = originalParameters.Count - reorderedParameters.Count;
return(SyntaxFactory.SeparatedList(newParameters, GetSeparators(list, numSeparatorsToSkip)));
}
public ChangeSignatureOptionsResult(SignatureChange updatedSignature, bool previewChanges)
{
UpdatedSignature = updatedSignature;
PreviewChanges = previewChanges;
}