Fix typo and grammaro in modules documentation

llvm-svn: 177544

1 files changed, 2 insertions, 2 deletions

diff --git a/clang/docs/Modules.rst b/clang/docs/Modules.rst
index f8d44b86bbb..9cc5ef8d762 100644
--- a/clang/docs/Modules.rst
+++ b/clang/docs/Modules.rst
@@ -96,7 +96,7 @@ Many programming languages have a module or package system, and because of the v
 
 * **Namespaces**: Unlike in some languages, modules do not imply any notion of namespaces. Thus, a struct declared in one module will still conflict with a struct of the same name declared in a different module, just as they would if declared in two different headers. This aspect is important for backward compatibility, because (for example) the mangled names of entities in software libraries must not change when introducing modules.
 
-* **Binary distribution of modules**: Headers (particularly C++ headers) expose the full complexity of the language. Maintaining a stable binary module format across archectures, compiler versions, and compiler vendors is technically infeasible.
+* **Binary distribution of modules**: Headers (particularly C++ headers) expose the full complexity of the language. Maintaining a stable binary module format across architectures, compiler versions, and compiler vendors is technically infeasible.
 
 Using Modules
 =============
@@ -110,7 +110,7 @@ The primary user-level feature of modules is the import operation, which provide
 
   #include <stdio.h>
 
-will be automatically mapped to an import of the module ``std.io``. Even with specific ``import`` syntax in the language, this particular feature is important for both adoption and backward compatibility: automatic translation of ``#include`` to ``import`` allows an application to get the benefits of modules (for any modules-enabled libraries) without any changes to the application itself. Thus, users can easily use modules with one compiler while falling back to the preprocessor-inclusion mechanism with other compilers.
+will be automatically mapped to an import of the module ``std.io``. Even with specific ``import`` syntax in the language, this particular feature is important for both adoption and backward compatibility: automatic translation of ``#include`` to ``import`` allows an application to get the benefits of modules (for all modules-enabled libraries) without any changes to the application itself. Thus, users can easily use modules with one compiler while falling back to the preprocessor-inclusion mechanism with other compilers.
 
 Module Maps
 -----------