Addressed some comments from j-hui

Author: fahadnayyar

documentation/cxx-interop/index.md

@@ -1255,9 +1255,12 @@ object.doSomething()
 // `object` will be released here.
 ```
 
-### Calling conventions when passing shared reference types from Swift to C++
-If a C++ shared reference type is passed as an argument to a C++ API from Swift, the Swift compiler guarantees that the passed value would be alive, and retains the ownership of the value. In other words, the argument is passed at `+0` and there is no transfer of ownership. 
-The C++ function is responsible for ensuring that the value pointed to by the parameter is alive during and at the end of the call. The C++ function should not assume it has ownership of the value and should do necessary retain operations if it is needs to take ownership.
+### Calling conventions when passing Shared Reference Types from Swift to C++
+
+If a C++ shared reference type is passed as an argument to a C++ API from Swift, the Swift compiler guarantees that the passed value would be alive, and retains the ownership of the value.
+In other words, the argument is passed at `+0` and there is no transfer of ownership.
+The C++ function is responsible for ensuring that the value pointed to by the parameter is alive during and at the end of the call.
+The C++ function should not assume it has ownership of the value and should do necessary retain operations if it is needs to take ownership.
 
 ```swift
 var obj = SharedObject.create()
@@ -1272,16 +1275,21 @@ void receiveSharedObject(SharedObject *sobj) {
 ```
 
 Note that if the argument is an inout (non-const reference) as shown below:
+
 ```c++
 void takeSharedObjectAsInout(SharedObject *& x) { ... }
 ```
 
 which would be imported in Swift as
+
 ```swift
 func takeSharedObjectAsInout(_ x: inout SharedObject) { ... }
 ```
 
- the C++ function can overwrite the value of the argument with the new value. However, the C++ function is responsible for releasing the old value, and ensuring that the new value is properly retained so that the Swift caller has ownership of the new value when the function returns. Adhering to these rules is necessary to safely and correctly pass around `SWIFT_SHARED_REFERENCE` between Swift and C++. These rules are also generally recommended conventions to manage shared objects that use reference counting.
+The C++ function can overwrite the value of the argument with the new value.
+However, the C++ function is responsible for releasing the old value, and ensuring that the new value is properly retained so that the Swift caller has ownership of the new value when the function returns.
+Adhering to these rules is necessary to safely and correctly pass around `SWIFT_SHARED_REFERENCE` between Swift and C++.
+These rules are also generally recommended conventions to manage shared objects that use reference counting.
 
 ### Inheritance and Virtual Member Functions