Add native TextBuffer implementation

[maxbrunsfeld]

Core functionality

• Implement basic text access methods in terms of an immutable, contiguous 'base text' and a mutable Patch. This representation will significantly improve our memory efficiency and data locality when dealing with large files, and allow many operations like serialize and isModified to perform well regardless of the file size.
  • randomized tests
• Implement TextBuffer::create_snapshot(). This will allow the text of the buffer to be used in a read-only fashion in a background thread, even while mutations are going on in the main thread. We will use this to add an asynchronous save method that does no copying.
  • randomized tests
• Implement Text::write. This will serialize a text slice to a C++ stream in a given encoding. We will use this when saving the buffer to write each chunk of the buffer to disk.
• Implement a text_diff method that returns a Patch that we can use to update markers correctly when the buffer's on-disk contents change. We'll use Google's diff-match-patch library for the diffing. The library has been ported to work with STL-compatible strings.
  • randomized tests
• Implement a search method that can be used to search for a given regex pattern in either the buffer or a snapshot of the buffer. We'll use the PRCE regex library since it supports a superset of the ECMAScript regex syntax, and it can search text that is stored in a non-contiguous structure, via the partial match API.
  • randomized tests
• Implement an efficient is_modified method that performs well regardless of the file size.
  • remove noop changes from patch after splicing, to avoid keeping unnecessary nodes
  • make is_modified work correctly even when there are outstanding snapshots
• Handle IO failure in .save and .load
• Get IO methods working on windows. On POSIX systems, we can use libiconv, which is installed on users' systems by default. On windows, we may be able to use a port of this library.

Optimizations

• Avoid any unnecessary copying in search.
• Optimize UTF8 transcoding performance using stdlib rather than iconv
• Use stdio rather than fstream to maximize IO performance
• Make sure that performance is ok when there is a large contiguous unsaved change.
• Make sure that performance is ok when there are huge numbers of edits
• In Patch::splice mutate nodes' existing text rather than creating new text.
• Avoid the overhead of storing old and new text pointers on each Patch node if we're not storing text in the Patch.

Integration

• Create node binding for TextBuffer
• Create emscripten binding for TextBuffer
• Implement an async TextBuffer.save
• Implement an async TextBuffer.load
• Add an API for retrieving the unsaved changes of a buffer efficiently, as a serialized Patch plus some digest of the buffer's base text
• Add an async TextBuffer.search API that we can use as an efficient for read operations that are currently slow for large files, such as checking if hard tabs are used, and checking what line endings are used.
• Use native buffer into text-buffer repo. (Use native buffer implementation from superstring text-buffer#225)
• Use new text-buffer branch in Atom (Use new native text-buffer implementation atom#14435)
  • Get Atom usable with new native TextBuffer implementation
  • Get all Atom tests passing
  • Get all bundled package tests passing