Implement simple JSON serializer

[jdisanti]

This adds a JSON serializer for #161. At this point, I've vetted that it meets the requirements of the code generator, although the generator is not finished yet. Posting this as its own PR to keep the reviews bite sized.

By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.

[rcoh]

LGTM!

Code looks good, just noted a few places where test coverage could be improved.

[rcoh]

I will leave this up to you, but I think we will probably want this library to handle numeric JSON conversion: https://github.com/awslabs/smithy-rs/blob/42c1f215a5f88cd58871117dee3a67fa5b0b318f/rust-runtime/smithy-types/src/lib.rs#L57

Otherwise, we'll need to handle it upstream in a bunch of different places

[jdisanti]

Oh, I wasn't aware of the Number type in smithy-types. That simplifies things considerably. Originally, I was thinking I would need to pull in the num crate in order to write a generic number function, or alternatively make a separate number function for each number type and have the code generator choose, but I settled for just calling to_string() everywhere this number function is called.

Will refactor.

[jdisanti]

Also moved the timestamp handling code out of the code gen and into the serializers so that it's not repeated everywhere.

[rcoh]

should be append_trusted_string

Suggested change

	append_string(&mut self.json, value);
	append_trusted_string(&mut self.json, value);

[rcoh]

I would probably renamed this string_unchecked — it's not that we trust/don't trust the string as much that we aren't going to check that it doesn't need to be escaped

[jdisanti]

I'll go with string_unchecked

[rcoh]

this can be append_trusted_string

[rcoh]

can you use value.is_nan()?

[rcoh]

I would add a comment that ryu::Buffer::new() and itoa::Buffer:new() are cheap. I assumed this allocated until I read the code, might as well save some future person from trying to optimize this.

In fact, itoa::write just calls itoa::Buffer::new()!

[rcoh]

Suggested change

	/// Writes an Instant `value` with the given `key` and `format`.
	/// Writes an Instant `value` to this array with `format`.

[rcoh]

you don't need to wrap the value in a structure here, you can call to_string on a string directly: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=dcc0f9d691e95c859419cc46cc2cc4e1

this applies here & can also simplify the float tests as well

[jdisanti]

TIL. Thanks, will simplify.

[rcoh]

not sure how this currently plays out in codegen but I might consider:

pub struct JsonValueWriter<'a> {
  json: &'a mut String,
}

// all writing of values goes through this one place
impl JsonValueWriter {
   pub fn null(self) {
     self.push_str("null");
   }
   pub fn boolean(self, value) {
      // ...
   }
   pub fn object(self) -> JsonObjectWriter { ... }
}

// then instead of having lots of duplicated methods between array and object:
impl JsonObjectWriter<'a> {
  pub fn key(&mut self, key: &str) -> JsonValueWriter {
    // write "key": with the comma tracking etc.
    JsonValueWriter { json: self.json }
  }
}

// then the usage would look like:
let mut obj_1 = JsonObjectWriter::new(&mut output);
obj_1.key("foo").boolean(true);
let mut nested = obj_1.key("nested").object();
nested.key("asdf").string("hello!");
nested.finish();
obj_1.finish();

[jdisanti]

I really like this idea. I'll simplify down to this in a follow up PR.