Make everything use active evals (#30)

* Add trace log level

* Use active eval to implement spdlog

* Split server/client active eval interfaces

Since all properties are *not* valid on both sides

* +200% fire resistance

* Implement exec using active evaluations

* Fully implement child process streams

* Watch impl, move child_process back to explicitly adding events

Automatically forwarding all events might be the right move, but wanna
think/discuss it a bit more because it didn't come out very cleanly.

* Would you like some args with that callback?

* Implement the rest of child_process using active evals

* Rampant memory leaks

Emit "kill" to active evaluations when client disconnects in order to
kill processes. Most likely won't be the final solution.

* Resolve some minor issues with output panel

* Implement node-pty with active evals

* Provide clearTimeout to vm sandbox

* Implement socket with active evals

* Extract some callback logic

Also remove some eval interfaces, need to re-think those.

* Implement net.Server and remainder of net.Socket using active evals

* Implement dispose for active evaluations

* Use trace for express requests

* Handle sending buffers through evaluation events

* Make event logging a bit more clear

* Fix some errors due to us not actually instantiating until connect/listen

* is this a commit message?

* We can just create the evaluator in the ctor

Not sure what I was thinking.

* memory leak for you, memory leak for everyone

* it's a ternary now

* Don't dispose automatically on close or error

The code may or may not be disposable at that point.

* Handle parsing buffers on the client side as well

* Remove unused protobuf

* Remove TypedValue

* Remove unused forkProvider and test

* Improve dispose pattern for active evals

* Socket calls close after error; no need to bind both

* Improve comment

* Comment is no longer wishy washy due to explicit boolean

* Simplify check for sendHandle and options

* Replace _require with __non_webpack_require__

Webpack will then replace this with `require` which we then provide to
the vm sandbox.

* Provide path.parse

* Prevent original-fs from loading

* Start with a pid of -1

vscode immediately checks the PID to see if the debug process launch
correctly, but of course we don't get the pid synchronously.

* Pass arguments to bootstrap-fork

* Fully implement streams

Was causing errors because internally the stream would set this.writing
to true and it would never become false, so subsequent messages would
never send.

* Fix serializing errors and streams emitting errors multiple times

* Was emitting close to data

* Fix missing path for spawned processes

* Move evaluation onDispose call

Now it's accurate and runs when the active evaluation has actually
disposed.

* Fix promisifying fs.exists

* Fix some active eval callback issues

* Patch existsSync in debug adapter

packages/protocol/src/proto/vscode_pb.js

@@ -1,6 +1,8 @@
 /**
  * @fileoverview
  * @enhanceable
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
  * @public
  */
 // GENERATED CODE -- DO NOT EDIT!
@@ -53,11 +55,12 @@ proto.SharedProcessActiveMessage.prototype.toObject = function(opt_includeInstan
  *     http://goto/soy-param-migration
  * @param {!proto.SharedProcessActiveMessage} msg The msg instance to transform.
  * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
  */
 proto.SharedProcessActiveMessage.toObject = function(includeInstance, msg) {
   var f, obj = {
-    socketPath: msg.getSocketPath(),
-    logPath: msg.getLogPath()
+    socketPath: jspb.Message.getFieldWithDefault(msg, 1, ""),
+    logPath: jspb.Message.getFieldWithDefault(msg, 2, "")
   };
 
   if (includeInstance) {
@@ -111,43 +114,34 @@ proto.SharedProcessActiveMessage.deserializeBinaryFromReader = function(msg, rea
 };
 
 
-/**
- * Class method variant: serializes the given message to binary data
- * (in protobuf wire format), writing to the given BinaryWriter.
- * @param {!proto.SharedProcessActiveMessage} message
- * @param {!jspb.BinaryWriter} writer
- */
-proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, writer) {
-  message.serializeBinaryToWriter(writer);
-};
-
-
 /**
  * Serializes the message to binary data (in protobuf wire format).
  * @return {!Uint8Array}
  */
 proto.SharedProcessActiveMessage.prototype.serializeBinary = function() {
   var writer = new jspb.BinaryWriter();
-  this.serializeBinaryToWriter(writer);
+  proto.SharedProcessActiveMessage.serializeBinaryToWriter(this, writer);
   return writer.getResultBuffer();
 };
 
 
 /**
- * Serializes the message to binary data (in protobuf wire format),
- * writing to the given BinaryWriter.
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.SharedProcessActiveMessage} message
  * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
  */
-proto.SharedProcessActiveMessage.prototype.serializeBinaryToWriter = function (writer) {
+proto.SharedProcessActiveMessage.serializeBinaryToWriter = function(message, writer) {
   var f = undefined;
-  f = this.getSocketPath();
+  f = message.getSocketPath();
   if (f.length > 0) {
     writer.writeString(
       1,
       f
     );
   }
-  f = this.getLogPath();
+  f = message.getLogPath();
   if (f.length > 0) {
     writer.writeString(
       2,
@@ -157,27 +151,18 @@ proto.SharedProcessActiveMessage.prototype.serializeBinaryToWriter = function (w
 };
 
 
-/**
- * Creates a deep clone of this proto. No data is shared with the original.
- * @return {!proto.SharedProcessActiveMessage} The clone.
- */
-proto.SharedProcessActiveMessage.prototype.cloneMessage = function() {
-  return /** @type {!proto.SharedProcessActiveMessage} */ (jspb.Message.cloneMessage(this));
-};
-
-
 /**
  * optional string socket_path = 1;
  * @return {string}
  */
 proto.SharedProcessActiveMessage.prototype.getSocketPath = function() {
-  return /** @type {string} */ (jspb.Message.getFieldProto3(this, 1, ""));
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
 };
 
 
-/** @param {string} value  */
+/** @param {string} value */
 proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) {
-  jspb.Message.setField(this, 1, value);
+  jspb.Message.setProto3StringField(this, 1, value);
 };
 
 
@@ -186,13 +171,13 @@ proto.SharedProcessActiveMessage.prototype.setSocketPath = function(value) {
  * @return {string}
  */
 proto.SharedProcessActiveMessage.prototype.getLogPath = function() {
-  return /** @type {string} */ (jspb.Message.getFieldProto3(this, 2, ""));
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
 };
 
 
-/** @param {string} value  */
+/** @param {string} value */
 proto.SharedProcessActiveMessage.prototype.setLogPath = function(value) {
-  jspb.Message.setField(this, 2, value);
+  jspb.Message.setProto3StringField(this, 2, value);
 };