Merge pull request #165 from dwrensha/typo

fix some typos

c++/src/capnp/compiler/node-translator.c++

@@ -604,12 +604,12 @@ private:
 
 class NodeTranslator::BrandScope: public kj::Refcounted {
   // Tracks the brand parameter bindings affecting the current scope. For example, if we are
-  // interpreting the type expression "Foo(Text).Bar", we would start with the curernt scopes
+  // interpreting the type expression "Foo(Text).Bar", we would start with the current scopes
   // BrandScope, create a new child BrandScope representing "Foo", add the "(Text)" parameter
   // bindings to it, then create a further child scope for "Bar". Thus the BrandScope for Bar
   // knows that Foo's parameter list has been bound to "(Text)".
   //
-  // TODO(cleaup): This is too complicated to live here. We should refactor this class and
+  // TODO(cleanup): This is too complicated to live here. We should refactor this class and
   //   BrandedDecl out into their own file, independent of NodeTranslator.
 
 public:

c++/src/capnp/layout.c++

@@ -311,7 +311,7 @@ struct WireHelpers {
   static KJ_ALWAYS_INLINE(word* allocate(
       WirePointer*& ref, SegmentBuilder*& segment, WordCount amount,
       WirePointer::Kind kind, BuilderArena* orphanArena)) {
-    // Allocate space in the mesasge for a new object, creating far pointers if necessary.
+    // Allocate space in the message for a new object, creating far pointers if necessary.
     //
     // * `ref` starts out being a reference to the pointer which shall be assigned to point at the
     //   new object.  On return, `ref` points to a pointer which needs to be initialized with

c++/src/capnp/rpc.capnp

@@ -1254,7 +1254,7 @@ using ThirdPartyCapId = AnyPointer;
 #
 # In a network where each vat has a public/private key pair, this could be a combination of the
 # third party's public key fingerprint, hints on how to connect to the third party (e.g. an IP
-# address), and the question ID used in the corresponding `Provide` mesasge sent to that third party
+# address), and the question ID used in the corresponding `Provide` message sent to that third party
 # (used to identify which capability to pick up).
 
 using JoinKeyPart = AnyPointer;

c++/src/capnp/schema.h

@@ -287,8 +287,8 @@ public:
   // value pointer itself can be treated as the root of an unchecked message -- if you know where
   // to find it, which is what this method helps you with.
   //
-  // For blobs, returns the offset of the begging of the blob's content within the first segment of
-  // the struct's schema.
+  // For blobs, returns the offset of the beginning of the blob's content within the first segment
+  // of the struct's schema.
   //
   // This is primarily useful for code generators.  The C++ code generator, for example, embeds
   // the entire schema as a raw word array within the generated code.  Of course, to implement

c++/src/kj/refcount.h

@@ -31,7 +31,7 @@
 namespace kj {
 
 class Refcounted: private Disposer {
-  // Subclass this to create a class that contains an atomic reference count.  Then, use
+  // Subclass this to create a class that contains a reference count. Then, use
   // `kj::refcounted<T>()` to allocate a new refcounted pointer.
   //
   // Do NOT use this lightly.  Refcounting is a crutch.  Good designs should strive to make object
@@ -43,7 +43,7 @@ class Refcounted: private Disposer {
   // manipulated only in one thread, because atomic (thread-safe) refcounting is surprisingly slow.
   //
   // In general, abstract classes should _not_ subclass this.  The concrete class at the bottom
-  // of the heirarchy should be the one to decide how it implements refcounting.  Interfaces should
+  // of the hierarchy should be the one to decide how it implements refcounting.  Interfaces should
   // expose only an `addRef()` method that returns `Own<InterfaceType>`.  There are two reasons for
   // this rule:
   // 1. Interfaces would need to virtually inherit Refcounted, otherwise two refcounted interfaces