Remove some mentions of "CodeQL" and fix typos

docs/language/learn-ql/advanced/constraining-types.rst

@@ -8,7 +8,7 @@ Type constraint methods
 
    Note
 
-   The examples below use the CodeQL library for Java. All CodeQL libraries support using these methods to constrain variables, the only difference is in the names of the classes used.
+   The examples below use the CodeQL library for Java. All libraries support using these methods to constrain variables, the only difference is in the names of the classes used.
 
 There are several ways of imposing type constraints on variables:
 

docs/language/learn-ql/database.rst

@@ -17,7 +17,7 @@ For a Java program, two key tables are:
 
 The CodeQL library defines classes to provide a layer of abstraction over each of these tables (and the related auxiliary tables): ``Expr`` and ``Stmt``.
 
-Most classes in the CodeQL library are similar: they are abstractions over one or more database tables. Looking at one of the CodeQL libraries illustrates this:
+Most classes in the library are similar: they are abstractions over one or more database tables. Looking at one of the libraries illustrates this:
 
 .. code-block:: ql
 

docs/language/learn-ql/intro-to-data-flow.rst

@@ -58,9 +58,9 @@ Computing an accurate and complete data flow graph presents several challenges:
 - Aliasing between variables can result in a single write changing the value that multiple pointers point to.
 - The data flow graph can be very large and slow to compute.
 
-To overcome these potential problems, two kinds of data flow are modeled in the CodeQL libraries:
+To overcome these potential problems, two kinds of data flow are modeled in the libraries:
 
-- Local data flow, concerning the data flow within a single function. When reasoning about local, you only considers edges between data flow nodes belonging to the same function.It is generally sufficiently fast, efficient and precise for many queries, and it is usually possible to compute the local data flow for all functions in a CodeQL database.
+- Local data flow, concerning the data flow within a single function. When reasoning about local data flow, you only consider edges between data flow nodes belonging to the same function. It is generally sufficiently fast, efficient and precise for many queries, and it is usually possible to compute the local data flow for all functions in a CodeQL database.
 
 - Global data flow, effectively considers the data flow within an entire program, by calculating data flow between functions and through object properties. Computing global data flow is typically more time and energy intensive than local data flow, therefore queries should be refined to look for more specific sources and sinks.
 
@@ -69,7 +69,7 @@ Many CodeQL queries contain examples of both local and global data flow analysis
 Normal data flow vs taint tracking
 **********************************
 
-In the standard CodeQL libraries, we make a distinction between 'normal' data flow and taint tracking.
+In the standard libraries, we make a distinction between 'normal' data flow and taint tracking.
 The normal data flow libraries are used to analyze the information flow in which data values are preserved at each step.
 
 For example, if you are tracking an insecure object ``x`` (which might be some untrusted or potentially malicious data), a step in the program may 'change' its value. So, in a simple process such as ``y = x + 1``, a normal data flow analysis will highlight the use of ``x``, but not ``y``.

docs/language/learn-ql/introduction-to-ql.rst

@@ -1,7 +1,7 @@
 Introduction to QL 
 ==================
 
-QL is a powerful query language that underlies CodeQL, which is used to analyze code.
+QL is the powerful query language that underlies CodeQL, which is used to analyze code.
 Queries written with CodeQL can find errors and uncover variants of important security vulnerabilities.
 Visit Semmle's `security research page <https://lgtm.com/security>`__ to read about examples of vulnerabilities that we have recently found in open source projects.
 

docs/language/learn-ql/writing-queries/introduction-to-queries.rst

@@ -30,7 +30,7 @@ For information on how to format your code when contributing queries to the GitH
 Basic query structure
 *********************
 
-`Queries <https://help.semmle.com/QL/ql-handbook/queries.html>`__ written with CodeQL have the file extension ``.ql``, and contain a ``select`` clause. Many of the existing CodeQL queries include additional optional information, and have the following structure::
+`Queries <https://help.semmle.com/QL/ql-handbook/queries.html>`__ written with CodeQL have the file extension ``.ql``, and contain a ``select`` clause. Many of the existing queries include additional optional information, and have the following structure::
 
     /**
      * 
@@ -85,9 +85,9 @@ When writing your own alert queries, you would typically import the standard lib
 - JavaScript/TypeScript: ``javascript``
 - Python: ``python``
 
-There are also CodeQL libraries containing commonly used predicates, types, and other modules associated with different analyses, including data flow, control flow, and taint-tracking. In order to calculate path graphs, path queries require you to import a data flow library into the query file. See :doc:`Constructing path queries <path-queries>` for further information.
+There are also libraries containing commonly used predicates, types, and other modules associated with different analyses, including data flow, control flow, and taint-tracking. In order to calculate path graphs, path queries require you to import a data flow library into the query file. See :doc:`Constructing path queries <path-queries>` for further information.
 
-You can explore the contents of all the standard CodeQL libraries in the `CodeQL library reference documentation <https://help.semmle.com/wiki/display/QL/QL+standard+libraries>`__, using `QL for Eclipse <https://help.semmle.com/ql-for-eclipse/Content/WebHelp/standard-queries.html>`__, or in the `GitHub repository <https://github.com/semmle/ql>`__.
+You can explore the contents of all the standard libraries in the `CodeQL library reference documentation <https://help.semmle.com/wiki/display/QL/QL+standard+libraries>`__, using `QL for Eclipse <https://help.semmle.com/ql-for-eclipse/Content/WebHelp/z-queries.html>`__, or in the `GitHub repository <https://github.com/semmle/ql>`__.
 
 
 Optional CodeQL classes and predicates

docs/language/learn-ql/writing-queries/path-queries.rst

@@ -6,7 +6,7 @@ Overview
 
 Security researchers are particularly interested in the way that information flows in a program. Many vulnerabilities are caused by seemingly benign data flowing to unexpected locations, and being used in a malicious way. 
 Path queries written with CodeQL are particularly useful for analyzing data flow as they can be used to track the path taken by a variable from its possible starting points (``source``) to its possible end points (``sink``).
-To model paths with CodeQL, your query must provide information about the ``source`` and the ``sink``, as well as the data flow steps that link them.
+To model paths, your query must provide information about the ``source`` and the ``sink``, as well as the data flow steps that link them.
 
 This topic provides information on how to structure a path query file so you can explore the paths associated with the results of data flow analysis. 
 
@@ -18,7 +18,7 @@ This topic provides information on how to structure a path query file so you can
 
 
 To learn more about modeling data flow with CodeQL, see :doc:`Introduction to data flow <../intro-to-data-flow>`.
-For more language-specific information on analyzing data flow see:
+For more language-specific information on analyzing data flow, see:
 
 - :doc:`Analyzing data flow in C/C++ <../cpp/dataflow>`
 - :doc:`Analyzing data flow in C# <../csharp/dataflow>`
@@ -103,7 +103,7 @@ Generating path explanations
 In order to generate path explanations, your query needs to compute a `path graph <https://en.wikipedia.org/wiki/Path_graph>`__.
 To do this you need to define a `query predicate <https://help.semmle.com/QL/ql-handbook/queries.html#query-predicates>`__ called ``edges`` in your query.
 This predicate defines the edge relations of the graph you are computing, and it is used to compute the paths related to each result that your query generates. 
-You can import a predefined ``edges`` predicate from a path graph module in one of the standard CodeQL data flow libraries. In addition to the path graph module, the data flow libraries contain the other ``classes``, ``predicates``, and ``modules`` that are commonly used in data flow analysis. The import statement to use depends on the language that you are analyzing.
+You can import a predefined ``edges`` predicate from a path graph module in one of the standard data flow libraries. In addition to the path graph module, the data flow libraries contain the other ``classes``, ``predicates``, and ``modules`` that are commonly used in data flow analysis. The import statement to use depends on the language that you are analyzing.
 
 For C/C++, C#. Java, and JavaScript you would use::
 
@@ -115,7 +115,7 @@ For Python, the ``Paths`` module contains the ``edges`` predicate::
 
     import semmle.python.security.Paths 
 
-You can also import libraries specifically designed to implement data flow analysis in various common frameworks and environments, and many additional libraries are included with CodeQL. To see examples of the different libraries used in data flow analysis, see the links to the built-in queries above or browse the `standard CodeQL libraries <https://help.semmle.com/wiki/display/QL/QL+standard+libraries>`__.
+You can also import libraries specifically designed to implement data flow analysis in various common frameworks and environments, and many additional libraries are included with CodeQL. To see examples of the different libraries used in data flow analysis, see the links to the built-in queries above or browse the `standard libraries <https://help.semmle.com/wiki/display/QL/QL+standard+libraries>`__.
 
 For all languages, you can also optionally define a ``nodes`` query predicate, which specifies the nodes of the path graph that you are interested in. If ``nodes`` is defined, only edges with endpoints defined by these nodes are selected. If ``nodes`` is not defined, you select all possible endpoints of ``edges``.