public SignatureChange(ParameterConfiguration originalConfiguration, ParameterConfiguration updatedConfiguration)
{
OriginalConfiguration = originalConfiguration;
UpdatedConfiguration = updatedConfiguration;
// TODO: Could be better than O(n^2)
var originalParameterList = originalConfiguration.ToListOfParameters();
var updatedParameterList = updatedConfiguration.ToListOfParameters();
for (var i = 0; i < originalParameterList.Count; i++)
{
int? index = null;
var parameter = originalParameterList[i];
if (parameter is ExistingParameter existingParameter)
{
var updatedIndex = updatedParameterList.IndexOf(p => p is ExistingParameter ep && ep.Symbol == existingParameter.Symbol);
if (updatedIndex >= 0)
{
index = updatedIndex;
}
}
_originalIndexToUpdatedIndexMap.Add(i, index);
}
}
internal ChangeSignatureDialogViewModel(INotificationService notificationService, ParameterConfiguration parameters, ISymbol symbol, ClassificationTypeMap classificationTypeMap)
{
_originalParameterConfiguration = parameters;
_notificationService = notificationService;
_classificationTypeMap = classificationTypeMap;
int startingSelectedIndex = 0;
if (parameters.ThisParameter != null)
{
startingSelectedIndex++;
_thisParameter = new ParameterViewModel(this, parameters.ThisParameter);
_disabledParameters.Add(parameters.ThisParameter);
}
if (parameters.ParamsParameter != null)
{
_paramsParameter = new ParameterViewModel(this, parameters.ParamsParameter);
}
_symbol = symbol;
_declarationParts = symbol.ToDisplayParts(s_symbolDeclarationDisplayFormat);
_parameterGroup1 = parameters.ParametersWithoutDefaultValues.Select(p => new ParameterViewModel(this, p)).ToList();
_parameterGroup2 = parameters.RemainingEditableParameters.Select(p => new ParameterViewModel(this, p)).ToList();
this.SelectedIndex = startingSelectedIndex;
}
private async Task <ChangeSignatureAnalyzedContext> GetContextAsync(Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken)
{
var symbol = GetInvocationSymbol(document, position, restrictToDeclarations, cancellationToken);
// Cross-lang symbols will show as metadata, so map it to source if possible.
symbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false) ?? symbol;
if (symbol == null)
{
return(new ChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
if (symbol is IMethodSymbol)
{
var method = symbol as IMethodSymbol;
var containingType = method.ContainingType;
if (method.Name == WellKnownMemberNames.DelegateBeginInvokeName &&
containingType != null &&
containingType.IsDelegateType() &&
containingType.DelegateInvokeMethod != null)
{
symbol = containingType.DelegateInvokeMethod;
}
}
if (symbol is IEventSymbol)
{
symbol = (symbol as IEventSymbol).Type;
}
if (symbol is INamedTypeSymbol)
{
var typeSymbol = symbol as INamedTypeSymbol;
if (typeSymbol.IsDelegateType() && typeSymbol.DelegateInvokeMethod != null)
{
symbol = typeSymbol.DelegateInvokeMethod;
}
}
if (symbol.Locations.Any(loc => loc.IsInMetadata))
{
return(new ChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DefinedInMetadata));
}
if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType))
{
return(new ChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
var parameterConfiguration = ParameterConfiguration.Create(symbol.GetParameters().ToList(), symbol is IMethodSymbol && (symbol as IMethodSymbol).IsExtensionMethod);
if (!parameterConfiguration.IsChangeable())
{
return(new ChangeSignatureAnalyzedContext(CannotChangeSignatureReason.InsufficientParameters));
}
return(new ChangeSignatureAnalyzedContext(document.Project.Solution, symbol, parameterConfiguration));
}
public ChangeSignatureAnalysisSucceededContext(
Document document, int positionForTypeBinding, ISymbol symbol, ParameterConfiguration parameterConfiguration, CodeCleanupOptionsProvider fallbackOptions)
{
Document = document;
Symbol = symbol;
ParameterConfiguration = parameterConfiguration;
PositionForTypeBinding = positionForTypeBinding;
FallbackOptions = fallbackOptions;
}
public ParameterConfiguration(Microsoft.CodeAnalysis.ChangeSignature.ParameterConfiguration inner)
{
_inner = inner;
ThisParameter = inner.ThisParameter;
ParametersWithoutDefaultValues = inner.ParametersWithoutDefaultValues;
RemainingEditableParameters = inner.RemainingEditableParameters;
ParamsParameter = inner.ParamsParameter;
SelectedIndex = inner.SelectedIndex;
}
public ChangeSignatureOptionsResult GetChangeSignatureOptions(ISymbol symbol, ParameterConfiguration parameters, INotificationService notificationService)
{
var list = parameters.ToListOfParameters();
return new ChangeSignatureOptionsResult
{
IsCancelled = IsCancelled,
UpdatedSignature = new SignatureChange(
parameters,
UpdatedSignature == null ? parameters : ParameterConfiguration.Create(UpdatedSignature.Select(i => list[i]).ToList(), parameters.ThisParameter != null))
};
}
public SignatureChange(ParameterConfiguration originalConfiguration, ParameterConfiguration updatedConfiguration)
{
OriginalConfiguration = originalConfiguration;
UpdatedConfiguration = updatedConfiguration;
// TODO: Could be better than O(n^2)
var originalParameterList = originalConfiguration.ToListOfParameters();
var updatedParameterList = updatedConfiguration.ToListOfParameters();
for (var i = 0; i < originalParameterList.Count; i++)
{
var parameter = originalParameterList[i];
var updatedIndex = updatedParameterList.IndexOf(parameter);
_originalIndexToUpdatedIndexMap.Add(i, updatedIndex != -1 ? updatedIndex : (int?)null);
}
}
public SignatureChange(ParameterConfiguration originalConfiguration, ParameterConfiguration updatedConfiguration)
{
this.OriginalConfiguration = originalConfiguration;
this.UpdatedConfiguration = updatedConfiguration;
// TODO: Could be better than O(n^2)
var originalParameterList = originalConfiguration.ToListOfParameters();
var updatedParameterList = updatedConfiguration.ToListOfParameters();
for (int i = 0; i < originalParameterList.Count; i++)
{
var parameter = originalParameterList[i];
var updatedIndex = updatedParameterList.IndexOf(parameter);
_originalIndexToUpdatedIndexMap.Add(i, updatedIndex != -1 ? updatedIndex : (int?)null);
}
}
public ChangeSignatureOptionsResult GetChangeSignatureOptions(ISymbol symbol, ParameterConfiguration parameters, INotificationService notificationService)
{
var viewModel = new ChangeSignatureDialogViewModel(notificationService, parameters, symbol, _classificationTypeMap);
var dialog = new ChangeSignatureDialog(viewModel);
var result = dialog.ShowModal();
if (result.HasValue && result.Value)
{
return new ChangeSignatureOptionsResult { IsCancelled = false, UpdatedSignature = new SignatureChange(parameters, viewModel.GetParameterConfiguration()), PreviewChanges = viewModel.PreviewChanges };
}
else
{
return new ChangeSignatureOptionsResult { IsCancelled = true };
}
}
private static SignatureChange CreateCompensatingSignatureChange(ISymbol declarationSymbol, SignatureChange updatedSignature)
{
if (declarationSymbol.GetParameters().Length > updatedSignature.OriginalConfiguration.ToListOfParameters().Count)
{
var origStuff = updatedSignature.OriginalConfiguration.ToListOfParameters();
var newStuff = updatedSignature.UpdatedConfiguration.ToListOfParameters();
var realStuff = declarationSymbol.GetParameters();
var bonusParameters = realStuff.Skip(origStuff.Count);
origStuff.AddRange(bonusParameters);
newStuff.AddRange(bonusParameters);
var newOrigParams = ParameterConfiguration.Create(origStuff, updatedSignature.OriginalConfiguration.ThisParameter != null);
var newUpdatedParams = ParameterConfiguration.Create(newStuff, updatedSignature.OriginalConfiguration.ThisParameter != null);
updatedSignature = new SignatureChange(newOrigParams, newUpdatedParams);
}
return(updatedSignature);
}
internal async Task <ChangeSignatureAnalyzedContext> GetContextAsync(
Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken)
{
var(symbol, selectedIndex) = await GetInvocationSymbolAsync(
document, position, restrictToDeclarations, cancellationToken).ConfigureAwait(false);
// Cross-language symbols will show as metadata, so map it to source if possible.
symbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false) ?? symbol;
if (symbol == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
if (symbol is IMethodSymbol method)
{
var containingType = method.ContainingType;
if (method.Name == WellKnownMemberNames.DelegateBeginInvokeName &&
containingType != null &&
containingType.IsDelegateType() &&
containingType.DelegateInvokeMethod != null)
{
symbol = containingType.DelegateInvokeMethod;
}
}
if (symbol is IEventSymbol ev)
{
symbol = ev.Type;
}
if (symbol is INamedTypeSymbol typeSymbol)
{
if (typeSymbol.IsDelegateType() && typeSymbol.DelegateInvokeMethod != null)
{
symbol = typeSymbol.DelegateInvokeMethod;
}
}
if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property))
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
if (symbol.Locations.Any(loc => loc.IsInMetadata))
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DefinedInMetadata));
}
// This should be called after the metadata check above to avoid looking for nodes in metadata.
var declarationLocation = symbol.Locations.FirstOrDefault();
if (declarationLocation == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DefinedInMetadata));
}
var solution = document.Project.Solution;
var declarationDocument = solution.GetRequiredDocument(declarationLocation.SourceTree !);
var declarationChangeSignatureService = declarationDocument.GetRequiredLanguageService <AbstractChangeSignatureService>();
int insertPosition;
var reference = symbol.DeclaringSyntaxReferences.FirstOrDefault();
if (reference != null)
{
insertPosition = declarationChangeSignatureService.GetPositionBeforeParameterListClosingBrace(reference.GetSyntax(cancellationToken));
}
else
{
// There may be no declaring syntax reference, for example delegate Invoke methods. Use an
// insertPosition of 0 and continue on.
insertPosition = 0;
}
var parameterConfiguration = ParameterConfiguration.Create(
symbol.GetParameters().Select(p => new ExistingParameter(p)).ToImmutableArray <Parameter>(),
symbol.IsExtensionMethod(), selectedIndex);
return(new ChangeSignatureAnalysisSucceededContext(
declarationDocument, insertPosition, symbol, parameterConfiguration));
}
internal async Task <ChangeSignatureAnalyzedContext> GetContextAsync(
Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken)
{
var(symbol, selectedIndex) = await GetInvocationSymbolAsync(
document, position, restrictToDeclarations, cancellationToken).ConfigureAwait(false);
// Cross-language symbols will show as metadata, so map it to source if possible.
symbol = await SymbolFinder.FindSourceDefinitionAsync(symbol, document.Project.Solution, cancellationToken).ConfigureAwait(false) ?? symbol;
if (symbol == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
if (symbol is IMethodSymbol method)
{
var containingType = method.ContainingType;
if (method.Name == WellKnownMemberNames.DelegateBeginInvokeName &&
containingType != null &&
containingType.IsDelegateType() &&
containingType.DelegateInvokeMethod != null)
{
symbol = containingType.DelegateInvokeMethod;
}
}
if (symbol is IEventSymbol ev)
{
symbol = ev.Type;
}
if (symbol is INamedTypeSymbol typeSymbol)
{
if (typeSymbol.IsDelegateType() && typeSymbol.DelegateInvokeMethod != null)
{
symbol = typeSymbol.DelegateInvokeMethod;
}
}
if (symbol.Locations.Any(loc => loc.IsInMetadata))
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DefinedInMetadata));
}
// This should be called after the metadata check above to avoid looking for nodes in metadata.
var declarationLocation = symbol.Locations.FirstOrDefault();
if (declarationLocation == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DefinedInMetadata));
}
var solution = document.Project.Solution;
var documentId = solution.GetDocumentId(declarationLocation.SourceTree);
var declarationDocument = solution.GetDocument(documentId);
var declarationChangeSignatureService = declarationDocument?.GetRequiredLanguageService <AbstractChangeSignatureService>();
if (declarationChangeSignatureService == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DeclarationLanguageServiceNotFound));
}
int?insertPositionOpt = declarationChangeSignatureService.TryGetInsertPositionFromDeclaration(symbol.Locations.FirstOrDefault().FindNode(cancellationToken));
if (insertPositionOpt == null)
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.DeclarationMethodPositionNotFound));
}
if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType))
{
return(new CannotChangeSignatureAnalyzedContext(CannotChangeSignatureReason.IncorrectKind));
}
var parameterConfiguration = ParameterConfiguration.Create(
symbol.GetParameters().Select(p => new ExistingParameter(p)),
symbol.IsExtensionMethod(), selectedIndex);
return(new ChangeSignatureAnalyzedSucceedContext(
declarationDocument ?? document, insertPositionOpt.Value, symbol, parameterConfiguration));
}
public ChangeSignatureOptionsResult?GetChangeSignatureOptions(Document document, int positionForTypeBinding, ISymbol symbol, Microsoft.CodeAnalysis.ChangeSignature.ParameterConfiguration parameters)
{
var viewModel = new ChangeSignatureDialogViewModel(new ParameterConfiguration(parameters), symbol);
var dialog = _dialogFactory.CreateExport().Value;
dialog.ViewModel = viewModel;
var result = dialog.Show();
return(result == true
? new ChangeSignatureOptionsResult(new SignatureChange(new ParameterConfiguration(parameters), viewModel.GetParameterConfiguration()).ToInternal(), previewChanges: false)
: null);
}
public ChangeSignatureOptionsResult GetChangeSignatureOptions(ISymbol symbol, Microsoft.CodeAnalysis.ChangeSignature.ParameterConfiguration parameters,
INotificationService notificationService)
{
var viewModel = new ChangeSignatureDialogViewModel(new ParameterConfiguration(parameters), symbol);
var dialog = new ChangeSignatureDialog(viewModel);
dialog.SetOwnerToActive();
var result = dialog.ShowDialog();
return(result == true
? new ChangeSignatureOptionsResult {
IsCancelled = false, UpdatedSignature = new SignatureChange(new ParameterConfiguration(parameters), viewModel.GetParameterConfiguration()).ToInternal()
}
: new ChangeSignatureOptionsResult {
IsCancelled = true
});
}
public ChangeSignatureOptionsResult GetChangeSignatureOptions(ISymbol symbol, Microsoft.CodeAnalysis.ChangeSignature.ParameterConfiguration parameters,
INotificationService notificationService)
{
var viewModel = new ChangeSignatureDialogViewModel(new ParameterConfiguration(parameters), symbol);
var dialog = _dialogFactory.CreateExport().Value;
dialog.ViewModel = viewModel;
var result = dialog.Show();
return(result == true
? new ChangeSignatureOptionsResult {
IsCancelled = false, UpdatedSignature = new SignatureChange(new ParameterConfiguration(parameters), viewModel.GetParameterConfiguration()).ToInternal()
}
: new ChangeSignatureOptionsResult {
IsCancelled = true
});
}