angelgarcia created this revision.
angelgarcia added a reviewer: alexfh.
angelgarcia added subscribers: klimek, cfe-commits.

Replace references to "transform" with references to "check" where neccessary 
in the documentation.

http://reviews.llvm.org/D13006

Files:
  docs/clang-tidy/checks/modernize-loop-convert.rst
  docs/clang-tidy/checks/modernize-pass-by-value.rst
  docs/clang-tidy/checks/modernize-replace-auto-ptr.rst
  docs/clang-tidy/checks/modernize-use-auto.rst
  docs/clang-tidy/checks/modernize-use-nullptr.rst

Index: docs/clang-tidy/checks/modernize-use-nullptr.rst
===================================================================
--- docs/clang-tidy/checks/modernize-use-nullptr.rst
+++ docs/clang-tidy/checks/modernize-use-nullptr.rst
@@ -38,7 +38,7 @@
 User defined macros
 ===================
 
-By default this transform will only replace the ``NULL`` macro and will skip any
+By default this check will only replace the ``NULL`` macro and will skip any
 user-defined macros that behaves like ``NULL``. The user can use the
 :option:``UserNullMacros`` option to specify a comma-separated list of macro
 names that will be transformed along with ``NULL``.
Index: docs/clang-tidy/checks/modernize-use-auto.rst
===================================================================
--- docs/clang-tidy/checks/modernize-use-auto.rst
+++ docs/clang-tidy/checks/modernize-use-auto.rst
@@ -53,7 +53,7 @@
   for (auto I = my_container.begin(), E = my_container.end(); I != E; ++I) {
   }
 
-The transform will only replace iterator type-specifiers when all of the
+The check will only replace iterator type-specifiers when all of the
 following conditions are satisfied:
 * The iterator is for one of the standard container in ``std`` namespace:
 
@@ -128,7 +128,7 @@
 
 Known Limitations
 =================
-* If the initializer is an explicit conversion constructor, the transform will
+* If the initializer is an explicit conversion constructor, the check will
   not replace the type specifier even though it would be safe to do so.
 * User-defined iterators are not handled at this time.
 
Index: docs/clang-tidy/checks/modernize-replace-auto-ptr.rst
===================================================================
--- docs/clang-tidy/checks/modernize-replace-auto-ptr.rst
+++ docs/clang-tidy/checks/modernize-replace-auto-ptr.rst
@@ -26,13 +26,13 @@
    }
 
 Since `std::move()` is a library function declared in `<utility>` it may be
-necessary to add this include. The transform will add the include directive when
+necessary to add this include. The check will add the include directive when
 necessary.
 
 Known Limitations
 =================
 * If headers modification is not activated or if a header is not allowed to be
-  changed this transform will produce broken code (compilation error), where the
+  changed this check will produce broken code (compilation error), where the
   the headers' code will stay unchanged while the code using them will be
   changed.
 
Index: docs/clang-tidy/checks/modernize-pass-by-value.rst
===================================================================
--- docs/clang-tidy/checks/modernize-pass-by-value.rst
+++ docs/clang-tidy/checks/modernize-pass-by-value.rst
@@ -4,7 +4,7 @@
 With move semantics added to the language and the standard library updated with
 move constructors added for many types it is now interesting to take an argument
 directly by value, instead of by const-reference, and then copy. This
-transformation allows the compiler to take care of choosing the best way to
+check allows the compiler to take care of choosing the best way to
 construct the copy.
 
 The transformation is usually beneficial when the calling code passes an
@@ -34,7 +34,7 @@
 into class fields. The parameter is then moved with `std::move()`.
 
 Since `std::move()` is a library function declared in `<utility>` it may be
-necessary to add this include. The transform will add the include directive when
+necessary to add this include. The check will add the include directive when
 necessary.
 
   .. code-block:: c++
Index: docs/clang-tidy/checks/modernize-loop-convert.rst
===================================================================
--- docs/clang-tidy/checks/modernize-loop-convert.rst
+++ docs/clang-tidy/checks/modernize-loop-convert.rst
@@ -81,19 +81,19 @@
   v.push_back(2);
   v.push_back(3);
 
-  // safe transform
+  // safe conversion
   for (int i = 0; i < N; ++i)
     cout << arr[i];
 
-  // reasonable transform
+  // reasonable conversion
   for (vector<int>::iterator it = v.begin(); it != v.end(); ++it)
     cout << *it;*
 
-  // reasonable transform
+  // reasonable conversion
   for (int i = 0; i < v.size(); ++i)
     cout << v[i];
 
-After transformation with confidence level set to ``reasonable`` (default):
+After applying the check with minimum confidence level set to ``reasonable`` (default):
 
 .. code-block:: c++
 
@@ -104,24 +104,24 @@
   v.push_back(2);
   v.push_back(3);
 
-  // safe transform
+  // safe conversion
   for (auto & elem : arr)
     cout << elem;
 
-  // reasonable transform
+  // reasonable conversion
   for (auto & elem : v)
     cout << elem;
 
-  // reasonable transform
+  // reasonable conversion
   for (auto & elem : v)
     cout << elem;
 
 Limitations
 ===========
 
 There are certain situations where the tool may erroneously perform
 transformations that remove information and change semantics. Users of the tool
-should be aware of the behaviour and limitations of the transform outlined by
+should be aware of the behaviour and limitations of the check outlined by
 the cases below.
 
 Comments inside loop headers
@@ -223,15 +223,15 @@
 Pointers and references to containers
 -------------------------------------
 
-While most of the transform's risk analysis is dedicated to determining whether
+While most of the check's risk analysis is dedicated to determining whether
 the iterator or container was modified within the loop, it is possible to
 circumvent the analysis by accessing and modifying the container through a
 pointer or reference.
 
 If the container were directly used instead of using the pointer or reference
 the following transformation would have only been applied at the ``risky``
 level since calling a member function of the container is considered `risky`.
-The transform cannot identify expressions associated with the container that are
+The check cannot identify expressions associated with the container that are
 different than the one used in the loop header, therefore the transformation
 below ends up being performed at the ``safe`` level.
 
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to