Merge pull request #2180 from shati-patel/docs/renaming

Docs: Update terminology

Author: Felicity Chapman

docs/language/global-sphinx-files/_templates/layout.html

@@ -61,7 +61,7 @@
             </div>
             <div class="linkcontainer">
                 <div class="linkbar">
-                    <a href="https://help.semmle.com/QL/learn-ql/" target="_blank">Learn QL</a>
+                    <a href="https://help.semmle.com/QL/learn-ql/" target="_blank">Learn CodeQL</a>
                     <a href="https://help.semmle.com/QL/learn-ql/ql-training.html" target="_blank">QL for variant analysis</a>
                     <a href="https://help.semmle.com/QL/ql-tools.html" target="_blank">QL tools</a>
                     <a href="https://help.semmle.com/QL/ql-explore-queries.html" target="_blank">Queries</a>

docs/language/learn-ql/about-ql.rst

@@ -1,11 +1,11 @@
 About QL
 ========
 
-This section is aimed at users with a background in general purpose programming as well as in databases. For a basic introduction and information on how to get started, see :doc:`Introduction to the QL language <introduction-to-ql>` and :doc:`Learning QL <../index>`.
+This section is aimed at users with a background in general purpose programming as well as in databases. For a basic introduction and information on how to get started, see :doc:`Introduction to QL <introduction-to-ql>` and :doc:`Learning CodeQL <../index>`.
 
 QL is a declarative, object-oriented query language that is optimized to enable efficient analysis of hierarchical data structures, in particular, databases representing software artifacts.
 
-The queries and metrics used in LGTM are implemented using QL. This ensures that they can be extended or revised easily to keep up with changes in definitions of best coding practice. We continually improve existing queries as we work towards the ultimate goal of 100% precision.
+The queries and metrics used in LGTM are implemented using CodeQL, which uses QL to analyze code. This ensures that they can be extended or revised easily to keep up with changes in definitions of best coding practice. We continually improve existing queries as we work towards the ultimate goal of 100% precision.
 
 You can write queries to identify security vulnerabilities, find coding errors and bugs, or find code that breaks your team's guidelines for best practice. You can also create customized versions of the default queries to accommodate a new framework.
 

docs/language/learn-ql/advanced/abstract-classes.rst

@@ -4,7 +4,7 @@ Semantics of abstract classes
 Concrete classes
 ----------------
 
-Concrete QL classes, as described in the QL language handbook topic on `Classes <https://help.semmle.com/QL/ql-handbook/types.html#classes>`__, lend themselves well to top-down modeling. We start from general superclasses representing large sets of values, and carve out individual subclasses representing more restricted sets of values.
+Concrete classes, as described in the QL language handbook topic on `Classes <https://help.semmle.com/QL/ql-handbook/types.html#classes>`__, lend themselves well to top-down modeling. We start from general superclasses representing large sets of values, and carve out individual subclasses representing more restricted sets of values.
 
 A classic example where this approach is useful is when modeling ASTs (Abstract Syntax Trees): the node types of an AST form a natural inheritance hierarchy, where, for example, there is a class ``Expr`` representing all expression nodes, with many different subclasses for different categories of expressions. There might be a class ``ArithmeticExpr`` representing arithmetic expressions, which in turn could have subclasses ``AddExpr`` and ``SubExpr``.
 
@@ -57,7 +57,7 @@ Like a concrete class, an abstract class has one or more superclasses and a char
 Example
 ~~~~~~~
 
-The following example is taken from the standard QL library for Java:
+The following example is taken from the CodeQL library for Java:
 
 .. code-block:: ql
 

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

@@ -8,7 +8,7 @@ Advanced QL
    ./*
 
 
-Topics on advanced uses of QL. These topics assume that you are familiar with the QL language and the basics of query writing.
+Topics on advanced uses of QL. These topics assume that you are familiar with QL and the basics of query writing.
 
 -  :doc:`Semantics of abstract classes <abstract-classes>`
 -  :doc:`Choosing appropriate ways to constrain types <constraining-types>`

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

@@ -8,7 +8,7 @@ Type constraint methods
 
    Note
 
-   The examples below use the Java QL library. All QL 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/advanced/determining-specific-types-variables.rst

@@ -1,14 +1,14 @@
 Determining the most specific types of a variable
 =================================================
 
-It is sometimes useful to be able to determine what QL types an entity has -- especially when you are unfamiliar with the QL library used by a query. To help with this, QL provides a predicate called ``getAQlClass()``, which returns the most specific QL types of the entity that it is called on.
+It is sometimes useful to be able to determine what types an entity has -- especially when you are unfamiliar with the library used by a query. To help with this, there is a predicate called ``getAQlClass()``, which returns the most specific QL types of the entity that it is called on.
 
 This can be useful when you are not sure of the most precise class of a value. Discovering a more precise class can allow you to cast to it and use predicates that are not available on the more general class.
 
 Example
 -------
 
-If you were working with a Java snapshot database, you might use ``getAQlClass()`` on every ``Expr`` in a callable called ``c``:
+If you were working with a Java database, you might use ``getAQlClass()`` on every ``Expr`` in a callable called ``c``:
 
 **Java example**
 
@@ -23,6 +23,6 @@ If you were working with a Java snapshot database, you might use ``getAQlClass()
        and e.getEnclosingCallable() = c
    select e, e.getAQlClass()
 
-The result of this query is a list of the most specific types of every ``Expr`` in that function. You will see multiple results for some expressions because that expression is represented by more than one QL type.
+The result of this query is a list of the most specific types of every ``Expr`` in that function. You will see multiple results for some expressions because that expression is represented by more than one type.
 
-For example, ``StringLiteral``\ s like ``"Hello"`` in Java belong to both the ``StringLiteral`` QL class (a specialization of the ``Literal`` QL class) and the ``CompileTimeConstantExpr`` QL class. So any instances of ``StringLiteral``\ s in the results will produce more than one result, one for each of the QL classes to which they belong.
+For example, ``StringLiteral``\ s like ``"Hello"`` in Java belong to both the ``StringLiteral`` class (a specialization of the ``Literal`` class) and the ``CompileTimeConstantExpr`` class. So any instances of ``StringLiteral``\ s in the results will produce more than one result, one for each of the classes to which they belong.

docs/language/learn-ql/advanced/equivalence.rst

@@ -6,7 +6,7 @@ The two expressions:
 #. ``a() != b()``
 #. ``not(a() = b())``
 
-look equivalent - so much so that inexperienced (and even experienced) QL programmers have been known to rewrite one as the other. However, they are not equivalent due to the quantifiers involved.
+look equivalent - so much so that inexperienced (and even experienced) programmers have been known to rewrite one as the other. However, they are not equivalent due to the quantifiers involved.
 
 Thinking of ``a()`` and ``b()`` as sets of values, the first expression says that there is a pair of values (one from each side of the inequality) which are different.
 

docs/language/learn-ql/advanced/monotonic-aggregates.rst

@@ -1,7 +1,7 @@
 Monotonic aggregates in QL
 ==========================
 
-In addition to standard QL aggregates, QL also supports *monotonic* aggregates. These are a slightly different way of computing aggregates which have some advantages, notably the ability to be used recursively, which normal aggregates do not have. You can enable them in a scope by adding the \ ``language[monotonicAggregates]`` pragma on a predicate, class, or module.
+In addition to standard aggregates, QL also supports *monotonic* aggregates. These are a slightly different way of computing aggregates which have some advantages, notably the ability to be used recursively, which normal aggregates do not have. You can enable them in a scope by adding the \ ``language[monotonicAggregates]`` pragma on a predicate, class, or module.
 
 Syntax
 ------

docs/language/learn-ql/beginner/find-thief-3.rst

@@ -77,4 +77,4 @@ What next?
 
 -  Help the villagers track down another criminal in the :doc:`next tutorial <fire-1>`.
 -  Find out more about the concepts you discovered in this tutorial in the `QL language handbook <https://help.semmle.com/QL/ql-handbook/index.html>`__.
--  Explore the libraries that help you get data about code in :doc:`Learning QL <../../index>`.
+-  Explore the libraries that help you get data about code in :doc:`Learning CodeQL <../../index>`.

docs/language/learn-ql/beginner/fire-2.rst

@@ -40,4 +40,4 @@ What next?
 
 -  Find out who will be the new ruler of the village in the :doc:`next tutorial <heir>`.
 -  Learn more about predicates and classes in the `QL language handbook <https://help.semmle.com/QL/ql-handbook/index.html>`__.
--  Explore the libraries that help you get data about code in :doc:`Learning QL <../../index>`.
+-  Explore the libraries that help you get data about code in :doc:`Learning CodeQL <../../index>`.