[CPP-418] Address review comments.

2025-12-22 11:46:32 +01:00 · 2019-09-16 16:34:17 -07:00
parent e2d5a82735
commit 6eac51dba4
5 changed files with 101 additions and 96 deletions
--- a/cpp/ql/src/semmle/code/cpp/Type.qll
+++ b/cpp/ql/src/semmle/code/cpp/Type.qll
@@ -312,7 +312,7 @@ class BuiltInType extends Type, @builtintype {
 /**
 * An erroneous type.  This type has no corresponding C/C++ syntax.
 *
- * ErroneousType is the type of ErrorExpr, which it turn refers to an illegal
+ * ErroneousType is the type of ErrorExpr, which in turn refers to an illegal
 * language construct.  In the example below, a temporary (`0`) cannot be bound
 * to an lvalue reference (`int &`):
 * ```
@@ -1335,7 +1335,6 @@ class FunctionPointerIshType extends DerivedType {
 * int C::* p = &C::m;          // pointer to data member m of class C
 * class C *;
 * int val = c.*p;              // access data member
- *
 * ```
 */
 class PointerToMemberType extends Type, @ptrtomember {
@@ -1434,11 +1433,11 @@ class RoutineType extends Type, @routinetype {
 }

 /**
- * A C++ typename template parameter.
+ * A C++ `typename` (or `class`) template parameter.
 *
 * In the example below, `T` is a template parameter:
 * ```
- * template <typename T>
+ * template <class T>
 * class C { };
 * ```
 */
@@ -1458,8 +1457,8 @@ class TemplateParameter extends UserType {
 * In the example below, `T` is a template template parameter (although its name
 * may be omitted):
 * ```
- * template <template <typename T> class H, class S>
- * void f(const H<S> &value) { }
+ * template <template <typename T> class Container, class Elem>
+ * void foo(const ContainerH<Elem> &value) { }
 * ```
 */
 class TemplateTemplateParameter extends TemplateParameter {
--- a/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll
+++ b/cpp/ql/src/semmle/code/cpp/exprs/Assignment.qll
@@ -11,7 +11,7 @@ import semmle.code.cpp.exprs.BitwiseOperation
 */
 abstract class Assignment extends Operation {
  /** Gets the *lvalue* of this assignment. */
-  Expr get*lvalue*() { this.hasChild(result, 0) }
+  Expr getLValue() { this.hasChild(result, 0) }

  /** Gets the rvalue of this assignment. */
  Expr getRValue() { this.hasChild(result, 1) }
@@ -22,7 +22,7 @@ abstract class Assignment extends Operation {
    this.getRValue().mayBeGloballyImpure()
    or
    not exists(VariableAccess va, LocalScopeVariable v |
-      va = this.get*lvalue*() and
+      va = this.getLValue() and
      v = va.getTarget() and
      not va.getConversion+() instanceof ReferenceDereferenceExpr and
      not v.isStatic()
--- a/cpp/ql/src/semmle/code/cpp/exprs/BuiltInOperations.qll
+++ b/cpp/ql/src/semmle/code/cpp/exprs/BuiltInOperations.qll
@@ -78,29 +78,36 @@ class BuiltInNoOp extends BuiltInOperation, @noopexpr {
 }

 /**
- * A C++ `__offsetof` built-in operation (used by some implementations
- * of `offsetof` in the presence of user-defined `operator &`).
- *
- * It computes the offset (in bytes) of data member `m` from the beginning
- * of its enclosing `struct`/`class`/`union` `st`.
+ * DEPRECATED: Use `BuiltInOperationBuiltInOffsetOf` instead.
+ */
+deprecated class BuiltInOperationOffsetOf = BuiltInOperationBuiltInOffsetOf;
+
+/**
+ * A C/C++ `__offsetof` built-in operation (used by some implementations
+ * of `offsetof`).  The operation retains its semantics even in the presence
+ * of an overloaded `operator &`).  This is a GNU/Clang extension.
 * ```
- * #define offsetof(st, m) __offsetof(st, m)
+ * struct S {
+ *   int a, b;
+ * };
+ * int d = __builtin_offsetof(struct S, b); // usually 4 
 * ```
 */
-class BuiltInOperationOffsetOf extends BuiltInOperation, @offsetofexpr {
-  override string toString() { result = "__offsetof" }
+class BuiltInOperationBuiltInOffsetOf extends BuiltInOperation, @offsetofexpr {
+  override string toString() { result = "__builtin_offsetof" }

-  override string getCanonicalQLClass() { result = "BuiltInOperationOffsetOf" }
+  override string getCanonicalQLClass() { result = "BuiltInOperationBuiltInOffsetOf" }
 }

 /**
- * A C/C++ `__INTADDR__` expression, used by EDG to implement `offsetof`
- * in the presence of user-defined `operator &`.
- *
- * It computes the offset (in bytes) of data member `m` from the beginning
- * of its enclosing `struct`/`class`/`union` `st`.
+ * A C/C++ `__INTADDR__` built-in operation (used by some implementations
+ * of `offsetof`).  The operation retains its semantics even in the presence
+ * of an overloaded `operator &`).  This is an EDG extension.
 * ```
- * #define offsetof(st, m) __INTADDR__(st, m)
+ * struct S {
+ *   int a, b;
+ * };
+ * int d = __INTADDR__(struct S, b); // usually 4 
 * ```
 */
 class BuiltInIntAddr extends BuiltInOperation, @intaddrexpr {
@@ -541,7 +548,7 @@ class BuiltInOperationIsDestructible extends BuiltInOperation, @isdestructibleex
 * The `__is_nothrow_destructible` built-in operation (used by some
 * implementations of the `<type_traits>` header).
 *
- * Returns `true` if the type is destructible and whose constructor, and those
+ * Returns `true` if the type is destructible and whose destructor, and those
 * of member data and any super`class`es all have an empty exception
 * specification.
 * ```
@@ -558,7 +565,7 @@ class BuiltInOperationIsNothrowDestructible extends BuiltInOperation, @isnothrow
 * The `__is_trivially_destructible` built-in operation (used by some
 * implementations of the `<type_traits>` header).
 *
- * Returns `true` if the type is destructible and whose constructor, and those
+ * Returns `true` if the type is destructible and whose destructor, and those
 * of member data and any super`class`es are all trivial (compiler-generated).
 * ```
 * bool v = __is_trivially_destructible(MyType);
@@ -575,8 +582,7 @@ class BuiltInOperationIsTriviallyDestructible extends BuiltInOperation, @istrivi
 * implementations of the `<type_traits>` header).
 *
 * Returns `true` if the assignment operator `C::operator =(const C& c)` is
- * trivial (compiler-generated).  The  * generated code will have resembled a
- * `memcpy` operation.
+ * trivial (compiler-generated).
 * ```
 * template<typename T>
 *   struct is_trivially_assignable
@@ -595,7 +601,7 @@ class BuiltInOperationIsTriviallyAssignable extends BuiltInOperation, @istrivial
 * implementations of the `<type_traits>` header).
 *
 * Returns true if there exists a `C::operator =(const C& c) nothrow`
- * assignment operator (i.e, with an empty excepion specification).
+ * assignment operator (i.e, with an empty exception specification).
 * ```
 * bool v = __is_nothrow_assignable(MyType);
 * ```
--- a/cpp/ql/src/semmle/code/cpp/exprs/Cast.qll
+++ b/cpp/ql/src/semmle/code/cpp/exprs/Cast.qll
@@ -22,17 +22,17 @@ abstract class Conversion extends Expr {
 /**
 * A C/C++ cast expression.
 *
- * To get the type which the expression is being cast to, use **Cast::getType()**.
+ * To get the type which the expression is being cast to, use `Cast::getType()`.
 *
- * There are two groups of subtypes of **Cast**. The first group differentiates
- * between the different cast syntax forms, e.g. **CStyleCast**, **StaticCast**,
+ * There are two groups of subtypes of `Cast`. The first group differentiates
+ * between the different cast syntax forms, e.g. `CStyleCast`, `StaticCast`,
 * etc. The second group differentiates between the semantic operation being
- * performed by the cast, e.g. **IntegralConversion**, **PointerBaseClassConversion**,
+ * performed by the cast, e.g. `IntegralConversion`, `PointerBaseClassConversion`,
 * etc.
 * The two groups are largely orthogonal to one another. For example, a
- * cast that is syntactically as **CStyleCast** may also be an **IntegralConversion**,
- * a **PointerBaseClassConversion**, or some other semantic conversion. Similarly,
- * a **PointerDerivedClassConversion** may also be a **CStyleCast** or a **StaticCast**.
+ * cast that is syntactically as `CStyleCast` may also be an `IntegralConversion`,
+ * a `PointerBaseClassConversion`, or some other semantic conversion. Similarly,
+ * a `PointerDerivedClassConversion` may also be a `CStyleCast` or a `StaticCast`.
 *
 * This is an abstract root QL class representing the different casts.  For
 * specific examples, consult the documentation for any of QL classes mentioned above.
@@ -47,7 +47,7 @@ abstract class Cast extends Conversion, @cast {

 /**
 * INTERNAL: Do not use.
- * Query predicates used to check invariants that should hold for all **Cast**
+ * Query predicates used to check invariants that should hold for all `Cast`
 * nodes. To run all sanity queries for the ASTs, including the ones below,
 * run "semmle/code/cpp/ASTSanity.ql".
 */
@@ -167,8 +167,8 @@ private predicate isPointerToMemberOrNullPointer(Type type) {
 * A conversion from one arithmetic or `enum` type to another.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class ArithmeticConversion extends Cast {
  ArithmeticConversion() {
@@ -184,8 +184,8 @@ class ArithmeticConversion extends Cast {
 * A conversion from one integral or enum type to another.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`,  `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class IntegralConversion extends ArithmeticConversion {
  IntegralConversion() {
@@ -204,8 +204,8 @@ class IntegralConversion extends ArithmeticConversion {
 * A conversion from one floating point type.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class FloatingPointConversion extends ArithmeticConversion {
  FloatingPointConversion() {
@@ -224,8 +224,8 @@ class FloatingPointConversion extends ArithmeticConversion {
 * A conversion from a floating point type to an integral or enum type.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class FloatingPointToIntegralConversion extends ArithmeticConversion {
  FloatingPointToIntegralConversion() {
@@ -244,8 +244,8 @@ class FloatingPointToIntegralConversion extends ArithmeticConversion {
 * A conversion from an integral or enum type to a floating point type.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class IntegralToFloatingPointConversion extends ArithmeticConversion {
  IntegralToFloatingPointConversion() {
@@ -264,13 +264,13 @@ class IntegralToFloatingPointConversion extends ArithmeticConversion {
 * A conversion from one pointer type to another.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`,  `ConstCast`
+ * or `ReinterpretCast` for more information.
 *
 * The conversion does
 * not modify the value of the pointer. For pointer conversions involving
- * casts between base and derived classes, please see see **BaseClassConversion** or
- * **DerivedClassConversion**.
+ * casts between base and derived classes, please see see `BaseClassConversion` or
+ * `DerivedClassConversion`.
 */
 class PointerConversion extends Cast {
  PointerConversion() {
@@ -290,13 +290,13 @@ class PointerConversion extends Cast {
 * A conversion from one pointer-to-member type to another.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 *
 * The conversion does not modify the value of the pointer-to-member.
 * For pointer-to-member conversions involving casts between base and
- * derived classes, please see **PointerToMemberBaseClassConversion**
- * or **PointerToMemberDerivedClassConversion**.
+ * derived classes, please see `PointerToMemberBaseClassConversion`
+ * or `PointerToMemberDerivedClassConversion`.
 */
 class PointerToMemberConversion extends Cast {
  PointerToMemberConversion() {
@@ -326,8 +326,8 @@ class PointerToMemberConversion extends Cast {
 * A conversion from a pointer type to an integral or enum type.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class PointerToIntegralConversion extends Cast {
  PointerToIntegralConversion() {
@@ -347,8 +347,8 @@ class PointerToIntegralConversion extends Cast {
 * A conversion from an integral or enum type to a pointer type.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class IntegralToPointerConversion extends Cast {
  IntegralToPointerConversion() {
@@ -369,8 +369,8 @@ class IntegralToPointerConversion extends Cast {
 * `false`, or `nullptr`. Returns `true` otherwise.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class BoolConversion extends Cast {
  BoolConversion() { conversionkinds(underlyingElement(this), 1) }
@@ -384,8 +384,8 @@ class BoolConversion extends Cast {
 * A conversion to `void`.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class VoidConversion extends Cast {
  VoidConversion() {
@@ -407,8 +407,8 @@ class VoidConversion extends Cast {
 * direct base classes.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class InheritanceConversion extends Cast {
  InheritanceConversion() {
@@ -463,8 +463,8 @@ private Class getConversionClass(Expr expr) {
 * *glvalue* of a direct or virtual base class.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class BaseClassConversion extends InheritanceConversion {
  BaseClassConversion() { conversionkinds(underlyingElement(this), 2) }
@@ -490,8 +490,8 @@ class BaseClassConversion extends InheritanceConversion {
 * to a direct derived class.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class DerivedClassConversion extends InheritanceConversion {
  DerivedClassConversion() { conversionkinds(underlyingElement(this), 3) }
@@ -512,8 +512,8 @@ class DerivedClassConversion extends InheritanceConversion {
 * of an immediate base class.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class PointerToMemberBaseClassConversion extends Cast {
  PointerToMemberBaseClassConversion() { conversionkinds(underlyingElement(this), 4) }
@@ -532,8 +532,8 @@ class PointerToMemberBaseClassConversion extends Cast {
 * of an immediate derived class.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class PointerToMemberDerivedClassConversion extends Cast {
  PointerToMemberDerivedClassConversion() { conversionkinds(underlyingElement(this), 5) }
@@ -553,8 +553,8 @@ class PointerToMemberDerivedClassConversion extends Cast {
 * derived classes, see `BaseClassConversion` and `DerivedClassConversion`.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class GlvalueConversion extends Cast {
  GlvalueConversion() { conversionkinds(underlyingElement(this), 6) }
@@ -581,8 +581,8 @@ class GlvalueConversion extends Cast {
 * to the reference.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`, `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class PrvalueAdjustmentConversion extends Cast {
  PrvalueAdjustmentConversion() { conversionkinds(underlyingElement(this), 7) }
@@ -812,8 +812,8 @@ class AlignofTypeOperator extends AlignofOperator {
 * A C/C++ array to pointer conversion.
 *
 * The conversion is either implicit or underlies a particular cast.
- * Please see **CStyleCast**, **StaticCast**,  **ConstCast**
- * or **ReinterpretCast** for more information.
+ * Please see `CStyleCast`, `StaticCast`,  `ConstCast`
+ * or `ReinterpretCast` for more information.
 */
 class ArrayToPointerConversion extends Conversion, @array_to_pointer {
  /** Gets a textual representation of this conversion. */
--- a/cpp/ql/src/semmle/code/cpp/exprs/Expr.qll
+++ b/cpp/ql/src/semmle/code/cpp/exprs/Expr.qll
@@ -202,24 +202,24 @@ class Expr extends StmtParent, @expr {
   * Gets a string representation of the value category of the expression.
   * This is intended only for debugging. The possible values are:
   *
-   * - "*lvalue*"
-   * - "*xvalue*"
-   * - "*prvalue*"
-   * - "*prvalue*(load)"
+   * - "lvalue"
+   * - "xvalue"
+   * - "prvalue"
+   * - "prvalue(load)"
   *
-   * The "*prvalue*(load)" string is used when the expression is a **prvalue**, but
-   * **hasLValueToRvalueConversion()** holds.
+   * The "prvalue*(load)" string is used when the expression is a *prvalue*, but
+   * `hasLValueToRvalueConversion()` holds.
   */
  string getValueCategoryString() {
    isLValueCategory() and
-    result = "*lvalue*"
+    result = "lvalue"
    or
    isXValueCategory() and
-    result = "*xvalue*"
+    result = "xvalue"
    or
    (
      isPRValueCategory() and
-      if hasLValueToRValueConversion() then result = "*prvalue*(load)" else result = "*prvalue*"
+      if hasLValueToRValueConversion() then result = "prvalue(load)" else result = "prvalue"
    )
  }

@@ -254,18 +254,18 @@ class Expr extends StmtParent, @expr {
  }

  /**
-   * Holds if this expression has undergone an *lvalue*-to-**rvalue** conversion to
+   * Holds if this expression has undergone an *lvalue*-to-*rvalue* conversion to
   * extract its value.
   * for example:
   * ```
   *  y = x;
   * ```
-   * The **VariableAccess** for `x` is a **prvalue**, and **hasLValueToRValueConversion()**
+   * The `VariableAccess` for `x` is a *prvalue*, and `hasLValueToRValueConversion()`
   * holds because the value of `x` was loaded from the location of `x`.
-   * The **VariableAccess** for `y` is an *lvalue*, and **hasLValueToRValueConversion()**
+   * The `VariableAccess` for `y` is an *lvalue*, and `hasLValueToRValueConversion()`
   * does not hold because the value of `y` was not extracted.
   *
-   * See [conv.lval] for more about the *lvalue*-to-**rvalue** conversion
+   * See [conv.lval] for more about the *lvalue*-to-*rvalue* conversion
   */
  predicate hasLValueToRValueConversion() { expr_isload(underlyingElement(this)) }

@@ -544,7 +544,7 @@ class ParenthesisExpr extends Conversion, @parexpr {
 /**
 * A C/C++ expression that has not been resolved.
 * 
- * It is assigned **ErroneousType** as its type.
+ * It is assigned `ErroneousType` as its type.
 */
 class ErrorExpr extends Expr, @errorexpr {
  override string toString() { result = "<error expr>" }
@@ -637,7 +637,7 @@ class AddressOfExpr extends UnaryOperation, @address_of {
 * An implicit conversion from type `T` to type `T &`.
 *
 * This typically occurs when an expression of type `T` is used to initialize a variable or parameter of
- * type `T &`, and is to reference types what **AddressOfExpr** is to pointer types, though this class is
+ * type `T &`, and is to reference types what `AddressOfExpr` is to pointer types, though this class is
 * considered to be a conversion rather than an operation, and as such doesn't occur in the main AST.
 * ```
 * int &var_ref = var;
@@ -654,7 +654,7 @@ class ReferenceToExpr extends Conversion, @reference_to {
 /**
 * An instance of the built-in unary `operator *` applied to a type.
 *
- * For user-defined overloads of `operator *`, see **OverloadedPointerDereferenceExpr**.
+ * For user-defined overloads of `operator *`, see `OverloadedPointerDereferenceExpr`.
 * ```
 * int var = *varptr;
 * ```
@@ -688,7 +688,7 @@ class PointerDereferenceExpr extends UnaryOperation, @indirect {
 * An implicit conversion from type `T &` to type `T`.
 *
 * This typically occurs when an variable of type `T &` is used in a context which expects type `T`, and
- * is to reference types what **PointerDereferenceExpr** is to pointer types - though this class is
+ * is to reference types what `PointerDereferenceExpr` is to pointer types - though this class is
 * considered to be a conversion rather than an operation, and as such doesn't occur in the main AST.
 * ```
 * float &f_ref = get_ref();
@@ -1116,7 +1116,7 @@ class NoExceptExpr extends Expr, @noexceptexpr {
 * of the template will instead contain the sequence of expressions given by expanding the fold.
 * ```
 * template < typename... T >
- * auto sum ( T <20> t ) { return ( t + ... + 0 ); }
+ * auto sum ( T... t ) { return ( t + ... + 0 ); }
 * ```
 */
 class FoldExpr extends Expr, @foldexpr {