anchor.diff:          let closingSnapshotPoint = closingPoint.GetPoint(subjectBuffer.CurrentSnapshot)
   
           if closingSnapshotPoint.Position > 0 then
  -            let caretPos = getCaretPosition this
  -
  -            if caretPos.HasValue && not (this.HasNoForwardTyping(caretPos.Value, closingSnapshotPoint.Subtract(1))) then
  -                true
  -            else
  -                false
  +            match tryGetCaretPosition this with
  +            | Some caretPos when not (this.HasNoForwardTyping(caretPos, closingSnapshotPoint.Subtract(1))) -> true
  +            | _ -> false
           else
               false
   
  
positive.code:     interface IBraceCompletionSessionProvider with
  
          member __.TryCreateSession(textView, openingPoint, openingBrace, closingBrace, session) =
              let textSnapshot = openingPoint.Snapshot
  
              let newSession =
                  match textSnapshot.GetOpenDocumentInCurrentContextWithChanges() with
                  | null -> null
                  | document ->
                      match getLanguageService<IEditorBraceCompletionSessionFactory> document with
                      | null -> null
                      | editorSessionFactory ->
                          // Brace completion is (currently) not cancellable.
                          let cancellationToken = CancellationToken.None
                          
                          match editorSessionFactory.TryCreateSession(document, openingPoint.Position, openingBrace, cancellationToken) with
                          | null -> null
                          | editorSession ->
                              let undoHistory = undoManager.GetTextBufferUndoManager(textView.TextBuffer).TextBufferUndoHistory
                              BraceCompletionSession(
                                  textView,
                                  openingPoint.Snapshot.TextBuffer,
                                  openingPoint, 
                                  openingBrace, 
                                  closingBrace, 
                                  undoHistory, 
                                  editorOperationsFactoryService, 
                                  editorSession) :> IBraceCompletionSession
  
              session <- newSession
  
              match session with
              | null -> false
  
negative.code:         member this.PreBackspace handledCommand =
              handledCommand <- false
  
              match tryGetCaretPosition this with
              | Some caretPos ->
                  let snapshot = subjectBuffer.CurrentSnapshot
  
                  if caretPos.Position > 0 &&
                          caretPos.Position - 1 = openingPoint.GetPoint(snapshot).Position &&
                          not this.HasForwardTyping then
                  
                      use undo = this.CreateUndoTransaction()
                      use edit = subjectBuffer.CreateEdit()
  
                      let span = SnapshotSpan(openingPoint.GetPoint(snapshot), closingPoint.GetPoint(snapshot))
  
                      edit.Delete(span.Span) |> ignore
  
                      if edit.HasFailedChanges then
                          edit.Cancel()
                          undo.Cancel()
                          Debug.Fail("Unable to clear braces")
                      else
                          // handle the command so the backspace does 
                          // not go through since we've already cleared the braces
                          handledCommand <- true
                          edit.Apply() |> ignore // FIXME: ApplyAndLogExceptions()
                          undo.Complete()
                          this.EndSession()
              | _ -> ()
             
          member __.PostBackspace() = ()
  
  