prototype of binding without controls

src/EditorFeatures/TestUtilities/ChangeSignature/TestChangeSignatureOptionsService.cs

@@ -5,6 +5,7 @@
 using Microsoft.CodeAnalysis.ChangeSignature;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Notification;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.Editor.UnitTests.ChangeSignature
 {
@@ -19,12 +20,12 @@ public TestChangeSignatureOptionsService()
         {
         }
 
-        public AddedParameterResult GetAddedParameter(Document document)
+        AddedParameterResult IChangeSignatureOptionsService.GetAddedParameter(Document document, TextSpan insertionSpan)
         {
             throw new System.NotImplementedException();
         }
 
-        public ChangeSignatureOptionsResult GetChangeSignatureOptions(ISymbol symbol, ParameterConfiguration parameters, Document document, INotificationService notificationService)
+        ChangeSignatureOptionsResult IChangeSignatureOptionsService.GetChangeSignatureOptions(ISymbol symbol, TextSpan insertionSpan, ParameterConfiguration parameters, Document document, INotificationService notificationService)
         {
             var list = parameters.ToListOfParameters();
 

src/Features/CSharp/Portable/ChangeSignature/CSharpChangeSignatureService.cs

@@ -8,7 +8,9 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Humanizer;
 using Microsoft.CodeAnalysis.ChangeSignature;
+using Microsoft.CodeAnalysis.CSharp.Formatting;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Formatting;
@@ -77,7 +79,7 @@ public CSharpChangeSignatureService()
         {
         }
 
-        public override async Task<(ISymbol symbol, int selectedIndex)> GetInvocationSymbolAsync(
+        public override async Task<(ISymbol symbol, int selectedIndex, int insertPosition)> GetInvocationSymbolAsync(
             Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken)
         {
             var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
@@ -111,12 +113,13 @@ public CSharpChangeSignatureService()
                 return default;
             }
 
+            var insertPosition = TryGetInsertPositionFromDeclaration(matchingNode);
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var symbol = semanticModel.GetDeclaredSymbol(matchingNode, cancellationToken);
             if (symbol != null)
             {
                 var selectedIndex = TryGetSelectedIndexFromDeclaration(position, matchingNode);
-                return (symbol, selectedIndex);
+                return (symbol, selectedIndex, insertPosition);
             }
 
             if (matchingNode.IsKind(SyntaxKind.ObjectCreationExpression))
@@ -128,13 +131,13 @@ public CSharpChangeSignatureService()
                     var typeSymbol = semanticModel.GetSymbolInfo(objectCreation.Type, cancellationToken).Symbol;
                     if (typeSymbol != null && typeSymbol.IsKind(SymbolKind.NamedType) && (typeSymbol as ITypeSymbol).TypeKind == TypeKind.Delegate)
                     {
-                        return (typeSymbol, 0);
+                        return (typeSymbol, 0, insertPosition);
                     }
                 }
             }
 
             var symbolInfo = semanticModel.GetSymbolInfo(matchingNode, cancellationToken);
-            return (symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.FirstOrDefault(), 0);
+            return (symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.FirstOrDefault(), 0, insertPosition);
         }
 
         private static int TryGetSelectedIndexFromDeclaration(int position, SyntaxNode matchingNode)
@@ -143,6 +146,13 @@ private static int TryGetSelectedIndexFromDeclaration(int position, SyntaxNode m
             return parameters != null ? GetParameterIndex(parameters.Parameters, position) : 0;
         }
 
+        // TODO this is a rough algorithm: find the first ( and add 1.
+        private static int TryGetInsertPositionFromDeclaration(SyntaxNode matchingNode)
+        {
+            var parameters = matchingNode.ChildNodes().OfType<ParameterListSyntax>().SingleOrDefault();
+            return parameters != null ? parameters.OpenParenToken.SpanStart + 1 : 0;
+        }
+
         private SyntaxNode GetMatchingNode(SyntaxNode node, bool restrictToDeclarations)
         {
             var matchKinds = restrictToDeclarations

src/Features/Core/Portable/ChangeSignature/AbstractChangeSignatureService.cs

@@ -27,7 +27,7 @@ internal abstract class AbstractChangeSignatureService : ILanguageService
         /// <summary>
         /// Determines the symbol on which we are invoking ReorderParameters
         /// </summary>
-        public abstract Task<(ISymbol symbol, int selectedIndex)> GetInvocationSymbolAsync(Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken);
+        public abstract Task<(ISymbol symbol, int selectedIndex, int insertPosition)> GetInvocationSymbolAsync(Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken);
 
         /// <summary>
         /// Given a SyntaxNode for which we want to reorder parameters/arguments, find the 
@@ -89,7 +89,7 @@ internal ChangeSignatureResult ChangeSignature(Document document, int position,
         internal async Task<ChangeSignatureAnalyzedContext> GetContextAsync(
             Document document, int position, bool restrictToDeclarations, CancellationToken cancellationToken)
         {
-            var (symbol, selectedIndex) = await GetInvocationSymbolAsync(
+            var (symbol, selectedIndex, insertPosition) = await GetInvocationSymbolAsync(
                 document, position, restrictToDeclarations, cancellationToken).ConfigureAwait(false);
 
             // Cross-language symbols will show as metadata, so map it to source if possible.
@@ -142,9 +142,8 @@ internal ChangeSignatureResult ChangeSignature(Document document, int position,
                 return new ChangeSignatureAnalyzedContext(CannotChangeSignatureReason.InsufficientParameters);
             }
 
-            // TODO add here a span to be typed in
             return new ChangeSignatureAnalyzedContext(
-                document, symbol, parameterConfiguration);
+                document, symbol, parameterConfiguration, new TextSpan(insertPosition, 0));
         }
 
         private async Task<ChangeSignatureResult> ChangeSignatureWithContextAsync(ChangeSignatureAnalyzedContext context, CancellationToken cancellationToken)
@@ -174,6 +173,7 @@ internal ChangeSignatureOptionsResult GetChangeSignatureOptions(ChangeSignatureA
 
             return changeSignatureOptionsService.GetChangeSignatureOptions(
                 context.Symbol,
+                context.InsertionSpan,
                 context.ParameterConfiguration,
                 context.Document,
                 notificationService);

src/Features/Core/Portable/ChangeSignature/ChangeSignatureAnalyzedContext.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using Microsoft.CodeAnalysis.Text;
+
 namespace Microsoft.CodeAnalysis.ChangeSignature
 {
     internal sealed class ChangeSignatureAnalyzedContext
@@ -10,17 +12,19 @@ internal sealed class ChangeSignatureAnalyzedContext
         public readonly ISymbol Symbol;
         public readonly CannotChangeSignatureReason CannotChangeSignatureReason;
         public readonly ParameterConfiguration ParameterConfiguration;
+        public readonly TextSpan InsertionSpan;
 
         public Solution Solution => Project.Solution;
 
         public ChangeSignatureAnalyzedContext(
-            Document document, ISymbol symbol, ParameterConfiguration parameterConfiguration)
+            Document document, ISymbol symbol, ParameterConfiguration parameterConfiguration, TextSpan insertionSpan)
         {
             CanChangeSignature = true;
             Document = document;
             Project = document.Project;
             Symbol = symbol;
             ParameterConfiguration = parameterConfiguration;
+            InsertionSpan = insertionSpan;
             CannotChangeSignatureReason = CannotChangeSignatureReason.None;
         }
 

src/Features/Core/Portable/ChangeSignature/IChangeSignatureOptionsService.cs

@@ -2,6 +2,7 @@
 
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Notification;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.ChangeSignature
 {
@@ -9,10 +10,11 @@ internal interface IChangeSignatureOptionsService : IWorkspaceService
     {
         ChangeSignatureOptionsResult GetChangeSignatureOptions(
             ISymbol symbol,
+            TextSpan insertionSpan,
             ParameterConfiguration parameters,
             Document document,
             INotificationService notificationService);
 
-        AddedParameterResult GetAddedParameter(Document document);
+        AddedParameterResult GetAddedParameter(Document document, TextSpan insertionSpan);
     }
 }

src/Features/VisualBasic/Portable/ChangeSignature/VisualBasicChangeSignatureService.vb

@@ -84,7 +84,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ChangeSignature
                 document As Document,
                 position As Integer,
                 restrictToDeclarations As Boolean,
-                cancellationToken As CancellationToken) As Task(Of (symbol As ISymbol, selectedIndex As Integer))
+                cancellationToken As CancellationToken) As Task(Of (symbol As ISymbol, selectedIndex As Integer, insertPosition As Integer))
             Dim tree = Await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(False)
             Dim token = tree.GetRoot(cancellationToken).FindToken(If(position <> tree.Length, position, Math.Max(0, position - 1)))
 
@@ -105,11 +105,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ChangeSignature
                 Return Nothing
             End If
 
+            Dim insertPosition = TryGetInsertPositionFromDeclaration(matchingNode)
             Dim semanticModel = Await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(False)
             Dim symbol = TryGetDeclaredSymbol(semanticModel, matchingNode, token, cancellationToken)
             If symbol IsNot Nothing Then
                 Dim selectedIndex = TryGetSelectedIndexFromDeclaration(position, matchingNode)
-                Return (symbol, selectedIndex)
+                Return (symbol, selectedIndex, insertPosition)
             End If
 
             If matchingNode.Kind() = SyntaxKind.ObjectCreationExpression Then
@@ -117,13 +118,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.ChangeSignature
                 If token.Parent.AncestorsAndSelf().Any(Function(a) a Is objectCreation.Type) Then
                     Dim typeSymbol = semanticModel.GetSymbolInfo(objectCreation.Type).Symbol
                     If typeSymbol IsNot Nothing AndAlso typeSymbol.IsKind(SymbolKind.NamedType) AndAlso DirectCast(typeSymbol, ITypeSymbol).TypeKind = TypeKind.Delegate Then
-                        Return (typeSymbol, 0)
+                        Return (typeSymbol, 0, insertPosition)
                     End If
                 End If
             End If
 
             Dim symbolInfo = semanticModel.GetSymbolInfo(matchingNode, cancellationToken)
-            Return (If(symbolInfo.Symbol, symbolInfo.CandidateSymbols.FirstOrDefault()), 0)
+            Return (If(symbolInfo.Symbol, symbolInfo.CandidateSymbols.FirstOrDefault()), 0, insertPosition)
+        End Function
+
+        ' TODO this Is a rough algorithm: find the first ( And add 1.
+        Private Shared Function TryGetInsertPositionFromDeclaration(matchingNode As SyntaxNode) As Integer
+            Dim parameters = matchingNode.ChildNodes().OfType(Of ParameterListSyntax)().SingleOrDefault()
+            Return If(parameters Is Nothing, 0, parameters.OpenParenToken.SpanStart + 1)
         End Function
 
         Private Function TryGetSelectedIndexFromDeclaration(position As Integer, matchingNode As SyntaxNode) As Integer

src/VisualStudio/Core/Def/Implementation/ChangeSignature/AddParameterDialog.xaml

@@ -40,7 +40,7 @@
                 <ColumnDefinition Width="400" />
             </Grid.ColumnDefinitions>
             <Label Grid.Row="0" Grid.Column="0" Content="{Binding ElementName=dialog, Path=TypeNameLabel}" />
-            <Border Grid.Row="0" Grid.Column="1" BorderThickness="1" Margin="6,0,0,0">
                <changesignature:IntellisenseTextBlock x:Name="TypeNameTextBox" Padding="0" Width="300" 
                                    Text="{Binding Value, UpdateSourceTrigger=PropertyChanged}" 
                                    Focusable="True"
                                    AutomationProperties.Name="{Binding SelectedCondition.DisplayName}" />
            </Border>
+            <Border Grid.Row="0" Grid.Column="1" BorderThickness="1" Margin="6,0,0,0">
                <changesignature:IntellisenseTextBlock x:Name="TypeNameTextBox" Width="300" Focusable="True" />
            </Border>
             <Label Grid.Row="1" Grid.Column="0" Content="{Binding ElementName=dialog, Path=ParameterNameLabel}" />
             <TextBox Grid.Row="1" Grid.Column="1" Width="200" Text="{Binding ParameterName}" />
             <Label Grid.Row="2" Grid.Column="0" Content="{Binding ElementName=dialog, Path=CallsiteValueLabel}" />

src/VisualStudio/Core/Def/Implementation/ChangeSignature/AddParameterTextViewModelProvider.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
-using System;
 using System.ComponentModel.Composition;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.VisualStudio.Text;
@@ -10,9 +9,6 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.ChangeSignature
 {
-    // TODO here or below, we need a split for different languages
-    // We may do this eiter creating such files for each content type or making the split below.
-    // Actually, ITextDataModel contains ContentType. So, we may do the split below.
     [Export(typeof(ITextViewModelProvider))]
     [ContentType(ContentTypeNames.RoslynContentType)]
     [TextViewRole(VisualStudioChangeSignatureOptionsService.AddParameterTextViewRole)]
@@ -23,34 +19,12 @@ internal class AddParameterTextViewModelProvider : ITextViewModelProvider
 
         public ITextViewModel CreateTextViewModel(ITextDataModel dataModel, ITextViewRoleSet roles)
         {
-            var namespaceSpan = GetNamespaceSpan(dataModel.DataBuffer.CurrentSnapshot);
-
-            var elisionBuffer = ProjectionBufferFactoryService.CreateElisionBuffer(
-                null,
-                new NormalizedSnapshotSpanCollection(namespaceSpan),
-                ElisionBufferOptions.None);
+            var elisionBuffer =
+                ProjectionBufferFactoryService.CreateElisionBuffer(/*resolver=*/null,
+                                            new NormalizedSnapshotSpanCollection(new SnapshotSpan(dataModel.DataBuffer.CurrentSnapshot, 85, 0)),
+                                            ElisionBufferOptions.None);                                            //dataModel.DataBuffer.ContentType);
 
             return new ElisionBufferTextViewModel(dataModel, elisionBuffer);
         }
-
-        private SnapshotSpan GetNamespaceSpan(ITextSnapshot snapshot)
-        {
-            var totalLineNumber = snapshot.LineCount;
-            var start = snapshot.GetLineFromLineNumber(0).Start;
-            for (int i = 0; i < totalLineNumber; i++)
-            {
-                var currentLine = snapshot.GetLineFromLineNumber(i);
-                string text = currentLine.GetText().Trim();
-                //if (text.StartsWith("public virtual SomeCollection<T> Include(string path) => null;", StringComparison.Ordinal))
-                if (text.StartsWith("namespace", StringComparison.Ordinal))
-                {
-                    int offset = "namespace".Length;
-                    return new SnapshotSpan(currentLine.Start + offset, text.Length - offset);
-                    //return new SnapshotSpan(currentLine.Start + text.IndexOf(")") - 1, 0);
-                }
-            }
-
-            throw new Exception("Unable to find namespace span.");
-        }
     }
 }

src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialog.xaml.cs

@@ -132,7 +132,7 @@ private void Restore_Click(object sender, RoutedEventArgs e)
         private void Add_Click(object sender, RoutedEventArgs e)
         {
             var changeSignatureOptionsService = _viewModel.Document.Project.Solution.Workspace.Services.GetService<IChangeSignatureOptionsService>();
-            var result = changeSignatureOptionsService.GetAddedParameter(_viewModel.Document);
+            var result = changeSignatureOptionsService.GetAddedParameter(_viewModel.Document, _viewModel.InsertionSpan);
 
             if (!result.IsCancelled)
             {

src/VisualStudio/Core/Def/Implementation/ChangeSignature/ChangeSignatureDialogViewModel.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Notification;
+using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
 using Microsoft.VisualStudio.Text.Classification;
 using Roslyn.Utilities;
@@ -30,6 +31,7 @@ internal class ChangeSignatureDialogViewModel : AbstractNotifyPropertyChanged
         private readonly List<ParameterViewModel> _parameterGroup2;
         private readonly ParameterViewModel _paramsParameter;
         private HashSet<ParameterViewModel> _disabledParameters = new HashSet<ParameterViewModel>();
+        public readonly TextSpan InsertionSpan;
 
         private ImmutableArray<SymbolDisplayPart> _declarationParts;
         private bool _previewChanges;
@@ -41,12 +43,14 @@ internal class ChangeSignatureDialogViewModel : AbstractNotifyPropertyChanged
             ParameterConfiguration parameters,
             ISymbol symbol,
             Document document,
+            TextSpan insertionSpan,
             IClassificationFormatMap classificationFormatMap,
             ClassificationTypeMap classificationTypeMap)
         {
             _originalParameterConfiguration = parameters;
             _notificationService = notificationService;
             Document = document;
+            InsertionSpan = insertionSpan;
             _classificationFormatMap = classificationFormatMap;
             _classificationTypeMap = classificationTypeMap;
 

src/VisualStudio/Core/Def/Implementation/ChangeSignature/VisualStudioChangeSignatureOptionsService.cs

@@ -20,6 +20,7 @@
 using Microsoft.VisualStudio.TextManager.Interop;
 using Microsoft.VisualStudio.Utilities;
 using ImportingConstructorAttribute = System.Composition.ImportingConstructorAttribute;
+using TextSpan = Microsoft.CodeAnalysis.Text.TextSpan;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.ChangeSignature
 {
@@ -58,6 +59,7 @@ internal class VisualStudioChangeSignatureOptionsService : IChangeSignatureOptio
 
         public ChangeSignatureOptionsResult GetChangeSignatureOptions(
             ISymbol symbol,
+            TextSpan insertionSpan,
             ParameterConfiguration parameters,
             Document document,
             INotificationService notificationService)
@@ -67,6 +69,7 @@ internal class VisualStudioChangeSignatureOptionsService : IChangeSignatureOptio
                 parameters,
                 symbol,
                 document,
+                insertionSpan,
                 _classificationFormatMap,
                 _classificationTypeMap);
 
@@ -77,15 +80,13 @@ internal class VisualStudioChangeSignatureOptionsService : IChangeSignatureOptio
             {
                 return new ChangeSignatureOptionsResult { IsCancelled = false, UpdatedSignature = new SignatureChange(parameters, viewModel.GetParameterConfiguration()), PreviewChanges = viewModel.PreviewChanges };
             }
-            else
-            {
-                return new ChangeSignatureOptionsResult { IsCancelled = true };
-            }
+
+            return new ChangeSignatureOptionsResult { IsCancelled = true };
         }
 
-        public AddedParameterResult GetAddedParameter(Document document)
+        public AddedParameterResult GetAddedParameter(Document document, TextSpan insertionSpan)
         {
-            var (dialog, viewModel) = CreateAddParameterDialogAsync(document, CancellationToken.None).Result;
+            var (dialog, viewModel) = CreateAddParameterDialogAsync(document, insertionSpan, CancellationToken.None).Result;
             var result = dialog.ShowModal();
 
             if (result.HasValue && result.Value)
@@ -106,22 +107,21 @@ public AddedParameterResult GetAddedParameter(Document document)
         }
 
         private async Task<(AddParameterDialog, AddParameterDialogViewModel)> CreateAddParameterDialogAsync(
-            Document document, CancellationToken cancellationToken)
+            Document document, TextSpan insertionSpan, CancellationToken cancellationToken)
         {
             var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var sourceText = await syntaxTree.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var documentText = sourceText.ToString();
 
             var roleSet = _textEditorFactoryService.CreateTextViewRoleSet(
-                PredefinedTextViewRoles.Document,
                 PredefinedTextViewRoles.Editable,
                 PredefinedTextViewRoles.Interactive,
                 AddParameterTextViewRole);
 
-            var vsTextView = _editorAdaptersFactoryService.CreateVsTextViewAdapter(_serviceProvider, roleSet);
             var vsTextBuffer = _editorAdaptersFactoryService.CreateVsTextBufferAdapter(_serviceProvider, _contentType);
             vsTextBuffer.InitializeContent(documentText, documentText.Length);
 
+            var vsTextView = _editorAdaptersFactoryService.CreateVsTextViewAdapter(_serviceProvider, roleSet);
             var initView = new[] {
                 new INITVIEW()
                 {
@@ -138,17 +138,11 @@ public AddedParameterResult GetAddedParameter(Document document)
                 (uint)TextViewInitFlags3.VIF_NO_HWND_SUPPORT,
                 initView);
 
-            var wpfTextView = _editorAdaptersFactoryService.GetWpfTextView(vsTextView);
-
             var originalContextBuffer = _editorAdaptersFactoryService.GetDataBuffer(vsTextBuffer);
             // Get the workspace, and from there, the solution and document containing this buffer.
             // If there's an ExternalSource, we won't get a document. Give up in that case.
             var solution = document.Project.Solution;
 
-            // Get the appropriate ITrackingSpan for the window the user is typing in
-            var viewSnapshot = wpfTextView.TextSnapshot;
-            var debuggerMappedSpan = CreateFullTrackingSpan(viewSnapshot, SpanTrackingMode.EdgeInclusive);
-
             // Wrap the original ContextBuffer in a projection buffer that we can make read-only
             var contextBuffer = _projectionBufferFactoryService.CreateProjectionBuffer(null,
                 new object[] { CreateFullTrackingSpan(originalContextBuffer.CurrentSnapshot, SpanTrackingMode.EdgeInclusive) }, ProjectionBufferOptions.None, _contentType);
@@ -163,18 +157,22 @@ public AddedParameterResult GetAddedParameter(Document document)
             // Adjust the context point to ensure that the right information is in scope.
             // For example, we may need to move the point to the end of the last statement in a method body
             // in order to be able to access all local variables.
-        //    var contextPoint = contextBuffer.CurrentSnapshot.GetLineFromLineNumber(currentStatementSpan.iEndLine).Start + currentStatementSpan.iEndIndex;
+            var contextPoint = insertionSpan.Start;
             //var adjustedContextPoint = GetAdjustedContextPoint(contextPoint, document);
+            var adjustedContextPoint = contextPoint;
 
             // Get the previous span/text. We might have to insert another newline or something.
-            //    var previousStatementSpan = GetPreviousStatementBufferAndSpan(adjustedContextPoint, document);
+            var previousStatementSpan = CreateTrackingSpanFromStartToIndex(contextBuffer.CurrentSnapshot, adjustedContextPoint, SpanTrackingMode.EdgeNegative);
+
+            // Get the appropriate ITrackingSpan for the window the user is typing in
+            var mappedSpan = contextBuffer.CurrentSnapshot.CreateTrackingSpan(adjustedContextPoint, 0, SpanTrackingMode.EdgeExclusive);
 
             // Build the tracking span that includes the rest of the file
-            //     var restOfFileSpan = CreateTrackingSpanFromIndexToEnd(contextBuffer.CurrentSnapshot, adjustedContextPoint, SpanTrackingMode.EdgePositive);
+            var restOfFileSpan = CreateTrackingSpanFromIndexToEnd(contextBuffer.CurrentSnapshot, adjustedContextPoint, SpanTrackingMode.EdgePositive);
 
             // Put it all into a projection buffer
             var projectionBuffer = _projectionBufferFactoryService.CreateProjectionBuffer(null,
-                new object[] { /* previousStatementSpan, */ debuggerMappedSpan, /* this.StatementTerminator */ /*, restOfFileSpan */}, ProjectionBufferOptions.None, _contentType);
+                new object[] { previousStatementSpan, mappedSpan, ";", restOfFileSpan }, ProjectionBufferOptions.None, _contentType);
 
             // Fork the solution using this new primary buffer for the document and all of its linked documents.
             var forkedSolution = solution.WithDocumentText(document.Id, projectionBuffer.CurrentSnapshot.AsText(), PreservationMode.PreserveIdentity);
@@ -195,6 +193,8 @@ public AddedParameterResult GetAddedParameter(Document document)
             // Start getting the compilation so the PartialSolution will be ready when the user starts typing in the window
             await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
 
+            // TODO here we should hook the projection buffer.
+            var wpfTextView = _editorAdaptersFactoryService.GetWpfTextView(vsTextView);
             wpfTextView.TextBuffer.ChangeContentType(_contentType, null);
 
             var viewModel = new AddParameterDialogViewModel();
@@ -216,5 +216,10 @@ public static ITrackingSpan CreateTrackingSpanFromIndexToEnd(ITextSnapshot textS
         {
             return textSnapshot.CreateTrackingSpan(Span.FromBounds(index, textSnapshot.Length), trackingMode);
         }
+
+        public static ITrackingSpan CreateTrackingSpanFromStartToIndex(ITextSnapshot textSnapshot, int index, SpanTrackingMode trackingMode)
+        {
+            return textSnapshot.CreateTrackingSpan(Span.FromBounds(0, index), trackingMode);
+        }
     }
 }

src/VisualStudio/Core/Test/ChangeSignature/ChangeSignatureViewModelTests.vb

@@ -439,6 +439,7 @@ class MyClass
                     ParameterConfiguration.Create(symbol.GetParameters().Select(Function(p) DirectCast(New ExistingParameter(p), Parameter)).ToList(), symbol.IsExtensionMethod(), selectedIndex:=0),
                     symbol,
                     workspaceDoc,
+                    insertionSpan:=New Microsoft.CodeAnalysis.Text.TextSpan(0, 0),
                     workspace.ExportProvider.GetExportedValue(Of IClassificationFormatMapService)().GetClassificationFormatMap("text"),
                     workspace.ExportProvider.GetExportedValue(Of ClassificationTypeMap)())
                 Return New ChangeSignatureViewModelTestState(viewModel, symbol.GetParameters())