[class.init] - C++17 → C++20

Files changed (1) hide show

tmp/tmpugo_pmh3/{from.md → to.md} +439 -41

tmp/tmpugo_pmh3/{from.md → to.md} RENAMED Viewed

@@ -34,24 +34,23 @@ struct complex {
   complex(double,double);
 };
 complex sqrt(complex,complex);
-complex a(1);                   // initialize by a call of complex(double)
-complex b = a;                  // initialize by a copy of a
-complex c = complex(1,2);       // construct complex(1,2) using complex(double,double),
- // copy/move it into c
-complex d = sqrt(b,c); // call sqrt(complex,complex) and copy/move the result into d
-complex e; // initialize by a call of complex()
-complex f = 3; // construct complex(3) using complex(double), copy/move it into f
-complex g = { 1, 2 };           // initialize by a call of complex(double, double)
 ```
 — *end example*]
-[*Note 1*:  Overloading of the assignment operator ([[over.ass]]) has
-no effect on initialization. — *end note*]
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
@@ -160,11 +159,11 @@ direct non-virtual base class and an inherited virtual base class, the
 ``` cpp
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
-C::C(): A() { }                 // ill-formed: which A?
 ```
 — *end example*]
 A *ctor-initializer* may initialize a variant member of the
@@ -217,12 +216,12 @@ D d(10);
 ```
 — *end example*]
 [*Note 2*: The initialization performed by each *mem-initializer*
-constitutes a full-expression ([[intro.execution]]). Any expression in
-a *mem-initializer* is evaluated as part of the full-expression that
 performs the initialization. — *end note*]
 A *mem-initializer* where the *mem-initializer-id* denotes a virtual
 base class is ignored during execution of a constructor of any class
 that is not the most derived class.
@@ -245,27 +244,27 @@ In a non-delegating constructor, if a given potentially constructed
 subobject is not designated by a *mem-initializer-id* (including the
 case where there is no *mem-initializer-list* because the constructor
 has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
-  initializer ([[class.mem]]) and either
-  - the constructor’s class is a union ([[class.union]]), and no other
     variant member of that union is designated by a *mem-initializer-id*
     or
   - the constructor’s class is not a union, and, if the entity is a
     member of an anonymous union, no other member of that union is
     designated by a *mem-initializer-id*,
   the entity is initialized from its default member initializer as
   specified in  [[dcl.init]];
-- otherwise, if the entity is an anonymous union or a variant member (
-  [[class.union.anon]]), no initialization is performed;
-- otherwise, the entity is default-initialized ([[dcl.init]]).
-[*Note 3*: An abstract class ([[class.abstract]]) is never a most
-derived class, thus its constructors never initialize virtual base
-classes, therefore the corresponding *mem-initializer*s may be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
@@ -337,22 +336,22 @@ A a2(1);                // OK, unfortunately
 ```
 — *end example*]
 In a non-delegating constructor, the destructor for each potentially
-constructed subobject of class type is potentially invoked (
-[[class.dtor]]).
 [*Note 5*: This provision ensures that destructors can be called for
-fully-constructed subobjects in case an exception is thrown (
-[[except.ctor]]). — *end note*]
 In a non-delegating constructor, initialization proceeds in the
 following order:
-- First, and only for the constructor of the most derived class (
-  [[intro.object]]), virtual base classes are initialized in the order
   they appear on a depth-first left-to-right traversal of the directed
   acyclic graph of base classes, where “left-to-right” is the order of
   appearance of the base classes in the derived class
   *base-specifier-list*.
 - Then, direct base classes are initialized in declaration order as they
@@ -432,16 +431,16 @@ the constructor, the `this` pointer can be used in the *expression-list*
 of a *mem-initializer* to refer to the object being
 initialized. — *end note*]
 Member functions (including virtual member functions, [[class.virtual]])
 can be called for an object under construction. Similarly, an object
-under construction can be the operand of the `typeid` operator (
-[[expr.typeid]]) or of a `dynamic_cast` ([[expr.dynamic.cast]]).
-However, if these operations are performed in a *ctor-initializer* (or
-in a function called directly or indirectly from a *ctor-initializer*)
-before all the *mem-initializer*s for base classes have completed, the
-program has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
@@ -451,11 +450,11 @@ public:
 class B : public A {
   int j;
 public:
   int f();
-  B() : A(f()),     // undefined: calls member function but base A not yet initialized
   j(f()) { }        // well-defined: bases are all initialized
 };
 class C {
 public:
@@ -463,24 +462,24 @@ public:
 };
 class D : public B, C {
   int i;
 public:
-  D() : C(f()),     // undefined: calls member function but base C not yet initialized
   i(f()) { }        // well-defined: bases are all initialized
 };
 ```
 — *end example*]
 [*Note 8*:  [[class.cdtor]] describes the result of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
-well-defined cases; that is, describes the *polymorphic behavior* of an
 object under construction. — *end note*]
-A *mem-initializer* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]) that initializes the base classes specified by a pack
 expansion in the *base-specifier-list* for the class.
 [*Example 12*:
 ``` cpp
@@ -494,12 +493,12 @@ public:
 — *end example*]
 ### Initialization by inherited constructor <a id="class.inhctor.init">[[class.inhctor.init]]</a>
 When a constructor for type `B` is invoked to initialize an object of a
-different type `D` (that is, when the constructor was inherited (
-[[namespace.udecl]])), initialization proceeds as if a defaulted default
 constructor were used to initialize the `D` object and each base class
 subobject from which the constructor was inherited, except that the `B`
 subobject is initialized by the invocation of the inherited constructor.
 The complete initialization is considered to be a single function call;
 in particular, the initialization of the inherited constructor’s
@@ -580,11 +579,11 @@ struct V2 : virtual B { using B::B; };
 struct D2 : V1, V2 {
   using V1::V1;
   using V2::V2;
 };
-D1 d1(0);           // ill-formed: ambiguous
 D2 d2(0);           // OK: initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
@@ -598,5 +597,404 @@ P p(0);             // OK: use M(0) to initialize N's base class,
 When an object is initialized by an inherited constructor,
 initialization of the object is complete when the initialization of all
 subobjects is complete.

   complex(double,double);
 };
 complex sqrt(complex,complex);
+complex a(1);                   // initialized by calling complex(double) with argument 1
+complex b = a;                  // initialized as a copy of a
+complex c = complex(1,2);       // initialized by calling complex(double,double) with arguments 1 and 2
+complex d = sqrt(b,c);          // initialized by calling sqrt(complex,complex) with d as its result object
+complex e; // initialized by calling complex()
+complex f = 3; // initialized by calling complex(double) with argument 3
+complex g = { 1, 2 }; // initialized by calling complex(double, double) with arguments 1 and 2
 ```
 — *end example*]
+[*Note 1*:  Overloading of the assignment operator [[over.ass]] has no
+effect on initialization. — *end note*]
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
 ``` cpp
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
+C::C(): A() { }                 // error: which A?
 ```
 — *end example*]
 A *ctor-initializer* may initialize a variant member of the
 ```
 — *end example*]
 [*Note 2*: The initialization performed by each *mem-initializer*
+constitutes a full-expression [[intro.execution]]. Any expression in a
+*mem-initializer* is evaluated as part of the full-expression that
 performs the initialization. — *end note*]
 A *mem-initializer* where the *mem-initializer-id* denotes a virtual
 base class is ignored during execution of a constructor of any class
 that is not the most derived class.
 subobject is not designated by a *mem-initializer-id* (including the
 case where there is no *mem-initializer-list* because the constructor
 has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
+  initializer [[class.mem]] and either
+  - the constructor’s class is a union [[class.union]], and no other
     variant member of that union is designated by a *mem-initializer-id*
     or
   - the constructor’s class is not a union, and, if the entity is a
     member of an anonymous union, no other member of that union is
     designated by a *mem-initializer-id*,
   the entity is initialized from its default member initializer as
   specified in  [[dcl.init]];
+- otherwise, if the entity is an anonymous union or a variant member
+  [[class.union.anon]], no initialization is performed;
+- otherwise, the entity is default-initialized [[dcl.init]].
+[*Note 3*: An abstract class [[class.abstract]] is never a most derived
+class, thus its constructors never initialize virtual base classes,
+therefore the corresponding *mem-initializer*s may be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
 ```
 — *end example*]
 In a non-delegating constructor, the destructor for each potentially
+constructed subobject of class type is potentially invoked
+[[class.dtor]].
 [*Note 5*: This provision ensures that destructors can be called for
+fully-constructed subobjects in case an exception is thrown
+[[except.ctor]]. — *end note*]
 In a non-delegating constructor, initialization proceeds in the
 following order:
+- First, and only for the constructor of the most derived class
+  [[intro.object]], virtual base classes are initialized in the order
   they appear on a depth-first left-to-right traversal of the directed
   acyclic graph of base classes, where “left-to-right” is the order of
   appearance of the base classes in the derived class
   *base-specifier-list*.
 - Then, direct base classes are initialized in declaration order as they
 of a *mem-initializer* to refer to the object being
 initialized. — *end note*]
 Member functions (including virtual member functions, [[class.virtual]])
 can be called for an object under construction. Similarly, an object
+under construction can be the operand of the `typeid` operator
+[[expr.typeid]] or of a `dynamic_cast` [[expr.dynamic.cast]]. However,
+if these operations are performed in a *ctor-initializer* (or in a
+function called directly or indirectly from a *ctor-initializer*) before
+all the *mem-initializer*s for base classes have completed, the program
+has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
 class B : public A {
   int j;
 public:
   int f();
+  B() : A(f()),     // undefined behavior: calls member function but base A not yet initialized
   j(f()) { }        // well-defined: bases are all initialized
 };
 class C {
 public:
 };
 class D : public B, C {
   int i;
 public:
+  D() : C(f()),     // undefined behavior: calls member function but base C not yet initialized
   i(f()) { }        // well-defined: bases are all initialized
 };
 ```
 — *end example*]
 [*Note 8*:  [[class.cdtor]] describes the result of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
+well-defined cases; that is, describes the polymorphic behavior of an
 object under construction. — *end note*]
+A *mem-initializer* followed by an ellipsis is a pack expansion
+[[temp.variadic]] that initializes the base classes specified by a pack
 expansion in the *base-specifier-list* for the class.
 [*Example 12*:
 ``` cpp
 — *end example*]
 ### Initialization by inherited constructor <a id="class.inhctor.init">[[class.inhctor.init]]</a>
 When a constructor for type `B` is invoked to initialize an object of a
+different type `D` (that is, when the constructor was inherited
+[[namespace.udecl]]), initialization proceeds as if a defaulted default
 constructor were used to initialize the `D` object and each base class
 subobject from which the constructor was inherited, except that the `B`
 subobject is initialized by the invocation of the inherited constructor.
 The complete initialization is considered to be a single function call;
 in particular, the initialization of the inherited constructor’s
 struct D2 : V1, V2 {
   using V1::V1;
   using V2::V2;
 };
+D1 d1(0);           // error: ambiguous
 D2 d2(0);           // OK: initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
 When an object is initialized by an inherited constructor,
 initialization of the object is complete when the initialization of all
 subobjects is complete.
+### Construction and destruction <a id="class.cdtor">[[class.cdtor]]</a>
+For an object with a non-trivial constructor, referring to any
+non-static member or base class of the object before the constructor
+begins execution results in undefined behavior. For an object with a
+non-trivial destructor, referring to any non-static member or base class
+of the object after the destructor finishes execution results in
+undefined behavior.
+[*Example 1*:
+``` cpp
+struct X { int i; };
+struct Y : X { Y(); };                  // non-trivial
+struct A { int a; };
+struct B : public A { int j; Y y; };    // non-trivial
+extern B bobj;
+B* pb = &bobj;                          // OK
+int* p1 = &bobj.a;                      // undefined behavior: refers to base class member
+int* p2 = &bobj.y.i;                    // undefined behavior: refers to member's member
+A* pa = &bobj;                          // undefined behavior: upcast to a base class type
+B bobj;                                 // definition of bobj
+extern X xobj;
+int* p3 = &xobj.i;                      // OK, X is a trivial class
+X xobj;
+```
+For another example,
+``` cpp
+struct W { int j; };
+struct X : public virtual W { };
+struct Y {
+  int* p;
+  X x;
+  Y() : p(&x.j) {   // undefined, x is not yet constructed
+    }
+};
+```
+— *end example*]
+During the construction of an object, if the value of the object or any
+of its subobjects is accessed through a glvalue that is not obtained,
+directly or indirectly, from the constructor’s `this` pointer, the value
+of the object or subobject thus obtained is unspecified.
+[*Example 2*:
+``` cpp
+struct C;
+void no_opt(C*);
+struct C {
+  int c;
+  C() : c(0) { no_opt(this); }
+};
+const C cobj;
+void no_opt(C* cptr) {
+  int i = cobj.c * 100;         // value of cobj.c is unspecified
+  cptr->c = 1;
+  cout << cobj.c * 100          // value of cobj.c is unspecified
+       << '\n';
+}
+extern struct D d;
+struct D {
+  D(int a) : a(a), b(d.a) {}
+  int a, b;
+};
+D d = D(1);                     // value of d.b is unspecified
+```
+— *end example*]
+To explicitly or implicitly convert a pointer (a glvalue) referring to
+an object of class `X` to a pointer (reference) to a direct or indirect
+base class `B` of `X`, the construction of `X` and the construction of
+all of its direct or indirect bases that directly or indirectly derive
+from `B` shall have started and the destruction of these classes shall
+not have completed, otherwise the conversion results in undefined
+behavior. To form a pointer to (or access the value of) a direct
+non-static member of an object `obj`, the construction of `obj` shall
+have started and its destruction shall not have completed, otherwise the
+computation of the pointer value (or accessing the member value) results
+in undefined behavior.
+[*Example 3*:
+``` cpp
+struct A { };
+struct B : virtual A { };
+struct C : B { };
+struct D : virtual A { D(A*); };
+struct X { X(A*); };
+struct E : C, D, X {
+  E() : D(this),    // undefined behavior: upcast from E* to A* might use path E* → D* → A*
+                    // but D is not constructed
+                    // ``D((C*)this)'' would be defined: E* → C* is defined because E() has started,
+                    // and C* → A* is defined because C is fully constructed
+  X(this) {}        // defined: upon construction of X, C/B/D/A sublattice is fully constructed
+};
+```
+— *end example*]
+Member functions, including virtual functions [[class.virtual]], can be
+called during construction or destruction [[class.base.init]]. When a
+virtual function is called directly or indirectly from a constructor or
+from a destructor, including during the construction or destruction of
+the class’s non-static data members, and the object to which the call
+applies is the object (call it `x`) under construction or destruction,
+the function called is the final overrider in the constructor’s or
+destructor’s class and not one overriding it in a more-derived class. If
+the virtual function call uses an explicit class member access
+[[expr.ref]] and the object expression refers to the complete object of
+`x` or one of that object’s base class subobjects but not `x` or one of
+its base class subobjects, the behavior is undefined.
+[*Example 4*:
+``` cpp
+struct V {
+  virtual void f();
+  virtual void g();
+};
+struct A : virtual V {
+  virtual void f();
+};
+struct B : virtual V {
+  virtual void g();
+  B(V*, A*);
+};
+struct D : A, B {
+  virtual void f();
+  virtual void g();
+  D() : B((A*)this, this) { }
+};
+B::B(V* v, A* a) {
+  f();              // calls V::f, not A::f
+  g();              // calls B::g, not D::g
+  v->g();           // v is base of B, the call is well-defined, calls B::g
+  a->f();           // undefined behavior: a's type not a base of B
+}
+```
+— *end example*]
+The `typeid` operator [[expr.typeid]] can be used during construction or
+destruction [[class.base.init]]. When `typeid` is used in a constructor
+(including the *mem-initializer* or default member initializer
+[[class.mem]] for a non-static data member) or in a destructor, or used
+in a function called (directly or indirectly) from a constructor or
+destructor, if the operand of `typeid` refers to the object under
+construction or destruction, `typeid` yields the `std::type_info` object
+representing the constructor or destructor’s class. If the operand of
+`typeid` refers to the object under construction or destruction and the
+static type of the operand is neither the constructor or destructor’s
+class nor one of its bases, the behavior is undefined.
+`dynamic_cast`s [[expr.dynamic.cast]] can be used during construction or
+destruction [[class.base.init]]. When a `dynamic_cast` is used in a
+constructor (including the *mem-initializer* or default member
+initializer for a non-static data member) or in a destructor, or used in
+a function called (directly or indirectly) from a constructor or
+destructor, if the operand of the `dynamic_cast` refers to the object
+under construction or destruction, this object is considered to be a
+most derived object that has the type of the constructor or destructor’s
+class. If the operand of the `dynamic_cast` refers to the object under
+construction or destruction and the static type of the operand is not a
+pointer to or object of the constructor or destructor’s own class or one
+of its bases, the `dynamic_cast` results in undefined behavior.
+[*Example 5*:
+``` cpp
+struct V {
+  virtual void f();
+};
+struct A : virtual V { };
+struct B : virtual V {
+  B(V*, A*);
+};
+struct D : A, B {
+  D() : B((A*)this, this) { }
+};
+B::B(V* v, A* a) {
+  typeid(*this);                // type_info for B
+  typeid(*v);                   // well-defined: *v has type V, a base of B yields type_info for B
+  typeid(*a);                   // undefined behavior: type A not a base of B
+  dynamic_cast<B*>(v);          // well-defined: v of type V*, V base of B results in B*
+  dynamic_cast<B*>(a);          // undefined behavior: a has type A*, A not a base of B
+}
+```
+— *end example*]
+### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
+When certain criteria are met, an implementation is allowed to omit the
+copy/move construction of a class object, even if the constructor
+selected for the copy/move operation and/or the destructor for the
+object have side effects. In such cases, the implementation treats the
+source and target of the omitted copy/move operation as simply two
+different ways of referring to the same object. If the first parameter
+of the selected constructor is an rvalue reference to the object’s type,
+the destruction of that object occurs when the target would have been
+destroyed; otherwise, the destruction occurs at the later of the times
+when the two objects would have been destroyed without the
+optimization.[^14] This elision of copy/move operations, called *copy
+elision*, is permitted in the following circumstances (which may be
+combined to eliminate multiple copies):
+- in a `return` statement in a function with a class return type, when
+  the *expression* is the name of a non-volatile object with automatic
+  storage duration (other than a function parameter or a variable
+  introduced by the *exception-declaration* of a *handler*
+  [[except.handle]]) with the same type (ignoring cv-qualification) as
+  the function return type, the copy/move operation can be omitted by
+  constructing the object directly into the function call’s return
+  object
+- in a *throw-expression* [[expr.throw]], when the operand is the name
+  of a non-volatile object with automatic storage duration (other than a
+  function or catch-clause parameter) whose scope does not extend beyond
+  the end of the innermost enclosing *try-block* (if there is one), the
+  copy/move operation can be omitted by constructing the object directly
+  into the exception object
+- in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
+  parameter can be omitted and references to that copy replaced with
+  references to the corresponding parameter if the meaning of the
+  program will be unchanged except for the execution of a constructor
+  and destructor for the parameter copy object
+- when the *exception-declaration* of an exception handler
+  [[except.pre]] declares an object of the same type (except for
+  cv-qualification) as the exception object [[except.throw]], the copy
+  operation can be omitted by treating the *exception-declaration* as an
+  alias for the exception object if the meaning of the program will be
+  unchanged except for the execution of constructors and destructors for
+  the object declared by the *exception-declaration*. \[*Note 1*: There
+  cannot be a move from the exception object because it is always an
+  lvalue. — *end note*]
+Copy elision is not permitted where an expression is evaluated in a
+context requiring a constant expression [[expr.const]] and in constant
+initialization [[basic.start.static]].
+[*Note 2*: Copy elision might be performed if the same expression is
+evaluated in another context. — *end note*]
+[*Example 1*:
+``` cpp
+class Thing {
+public:
+  Thing();
+  ~Thing();
+  Thing(const Thing&);
+};
+Thing f() {
+  Thing t;
+  return t;
+}
+Thing t2 = f();
+struct A {
+  void *p;
+  constexpr A(): p(this) {}
+};
+constexpr A g() {
+  A loc;
+  return loc;
+}
+constexpr A a;          // well-formed, a.p points to a
+constexpr A b = g();    // error: b.p would be dangling[expr.const]
+void h() {
+  A c = g();            // well-formed, c.p may point to c or to an ephemeral temporary
+}
+```
+Here the criteria for elision can eliminate the copying of the object
+`t` with automatic storage duration into the result object for the
+function call `f()`, which is the global object `t2`. Effectively, the
+construction of the local object `t` can be viewed as directly
+initializing the global object `t2`, and that object’s destruction will
+occur at program exit. Adding a move constructor to `Thing` has the same
+effect, but it is the move construction from the object with automatic
+storage duration to `t2` that is elided.
+— *end example*]
+An *implicitly movable entity* is a variable of automatic storage
+duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. In the following copy-initialization
+contexts, a move operation might be used instead of a copy operation:
+- If the *expression* in a `return` [[stmt.return]] or `co_return`
+  [[stmt.return.coroutine]] statement is a (possibly parenthesized)
+  *id-expression* that names an implicitly movable entity declared in
+  the body or *parameter-declaration-clause* of the innermost enclosing
+  function or *lambda-expression*, or
+- if the operand of a *throw-expression* [[expr.throw]] is a (possibly
+  parenthesized) *id-expression* that names an implicitly movable entity
+  whose scope does not extend beyond the *compound-statement* of the
+  innermost *try-block* or *function-try-block* (if any) whose
+  *compound-statement* or *ctor-initializer* encloses the
+  *throw-expression*,
+overload resolution to select the constructor for the copy or the
+`return_value` overload to call is first performed as if the expression
+or operand were an rvalue. If the first overload resolution fails or was
+not performed, overload resolution is performed again, considering the
+expression or operand as an lvalue.
+[*Note 3*: This two-stage overload resolution must be performed
+regardless of whether copy elision will occur. It determines the
+constructor or the `return_value` overload to be called if elision is
+not performed, and the selected constructor or `return_value` overload
+must be accessible even if the call is elided. — *end note*]
+[*Example 2*:
+``` cpp
+class Thing {
+public:
+  Thing();
+  ~Thing();
+  Thing(Thing&&);
+private:
+  Thing(const Thing&);
+};
+Thing f(bool b) {
+  Thing t;
+  if (b)
+    throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
+  return t;             // OK: Thing(Thing&&) used (or elided) to return t
+}
+Thing t2 = f(false);    // OK: no extra copy/move performed, t2 constructed by call to f
+struct Weird {
+  Weird();
+  Weird(Weird&);
+};
+Weird g() {
+  Weird w;
+  return w;             // OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
+}
+```
+— *end example*]
+[*Example 3*:
+``` cpp
+template<class T> void g(const T&);
+template<class T> void f() {
+  T x;
+  try {
+    T y;
+    try { g(x); }
+    catch (...) {
+      if (/*...*/)
+        throw x;        // does not move
+      throw y;          // moves
+    }
+    g(y);
+  } catch(...) {
+    g(x);
+    g(y);               // error: y is not in scope
+  }
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa