[dcl.contract] - C++23 → Trunk

Files changed (1) hide show

tmp/tmppe2n1auv/{from.md → to.md} +259 -0

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

	@@ -0,0 +1,259 @@

+## Function contract specifiers <a id="dcl.contract">[[dcl.contract]]</a>
+### General <a id="dcl.contract.func">[[dcl.contract.func]]</a>
+``` bnf
+function-contract-specifier-seq:
+    function-contract-specifier function-contract-specifier-seqₒₚₜ
+```
+``` bnf
+function-contract-specifier:
+  precondition-specifier
+  postcondition-specifier
+```
+``` bnf
+precondition-specifier:
+  'pre' attribute-specifier-seqₒₚₜ '(' conditional-expression ')'
+```
+``` bnf
+postcondition-specifier:
+  'post' attribute-specifier-seqₒₚₜ '(' result-name-introducerₒₚₜ conditional-expression ')'
+```
+A *function contract assertion* is a contract assertion
+[[basic.contract.general]] associated with a function. A
+*precondition-specifier* introduces a *precondition assertion*, which is
+a function contract assertion associated with entering a function. A
+*postcondition-specifier* introduces a *postcondition assertion*, which
+is a function contract assertion associated with exiting a function
+normally.
+[*Note 1*: A postcondition assertion is not associated with exiting a
+function in any other fashion, such as via an exception [[expr.throw]]
+or via a call to `longjmp` [[csetjmp.syn]]. — *end note*]
+The predicate [[basic.contract.general]] of a function contract
+assertion is its *conditional-expression* contextually converted to
+`bool`.
+Each *function-contract-specifier* of a
+*function-contract-specifier-seq* (if any) of an unspecified first
+declaration [[basic.def]] of a function introduces a corresponding
+function contract assertion for that function. The optional
+*attribute-specifier-seq* following `pre` or `post` appertains to the
+introduced contract assertion.
+[*Note 2*: The *function-contract-specifier-seq* of a
+*lambda-declarator* applies to the function call operator or operator
+template of the corresponding closure type
+[[expr.prim.lambda.closure]]. — *end note*]
+A declaration D of a function or function template *f* that is not a
+first declaration shall have either no *function-contract-specifier-seq*
+or the same *function-contract-specifier-seq* (see below) as any first
+declaration F reachable from D. If D and F are in different translation
+units, a diagnostic is required only if D is attached to a named module.
+If a declaration F₁ is a first declaration of `f` in one translation
+unit and a declaration F₂ is a first declaration of `f` in another
+translation unit, F₁ and F₂ shall specify the same
+*function-contract-specifier-seq*, no diagnostic required.
+A *function-contract-specifier-seq* S₁ is the same as a
+*function-contract-specifier-seq* S₂ if S₁ and S₂ consist of the same
+*function-contract-specifier*s in the same order. A
+*function-contract-specifier* C₁ on a function declaration D₁ is the
+same as a *function-contract-specifier* C₂ on a function declaration D₂
+if
+- their predicates P₁ and P₂ would satisfy the one-definition rule
+  [[basic.def.odr]] if placed in function definitions on the
+  declarations D₁ and D₂, respectively, except for
+  - renaming of the parameters of *f*,
+  - renaming of template parameters of a template enclosing **, and
+  - renaming of the result binding [[dcl.contract.res]], if any,
+  and, if D₁ and D₂ are in different translation units, corresponding
+  entities defined within each predicate behave as if there is a single
+  entity with a single definition, and
+- both C₁ and C₂ specify a *result-name-introducer* or neither do.
+If this condition is not met solely due to the comparison of two
+*lambda-expression*s that are contained within P₁ and P₂, no diagnostic
+is required.
+[*Note 3*: Equivalent *function-contract-specifier-seq*s apply to all
+uses and definitions of a function across all translation
+units. — *end note*]
+[*Example 1*:
+``` cpp
+bool b1, b2;
+void f() pre (b1) pre ([]{ return b2; }());
+void f();                       // OK, function-contract-specifiers omitted
+void f() pre (b1) pre ([]{ return b2; }()); // error: closures have different types.
+void f() pre (b1);              // error: function-contract-specifiers only partially repeated
+int g() post(r : b1);
+int g() post(b1);       // error: mismatched result-name-introducer presence
+namespace N {
+  void h() pre (b1);
+  bool b1;
+  void h() pre (b1);    // error: function-contract-specifiers differ according to
+                        // the one-definition rule[basic.def.odr].
+}
+```
+— *end example*]
+A virtual function [[class.virtual]], a deleted function
+[[dcl.fct.def.delete]], or a function defaulted on its first declaration
+[[dcl.fct.def.default]] shall not have a
+*function-contract-specifier-seq*.
+If the predicate of a postcondition assertion of a function *f* odr-uses
+[[basic.def.odr]] a non-reference parameter of *f*, that parameter and
+the corresponding parameter on all declarations of *f* shall have
+`const` type.
+[*Note 4*:
+This requirement applies even to declarations that do not specify the
+*postcondition-specifier*. Parameters with array or function type will
+decay to non-`const` types even if a `const` qualifier is present.
+[*Example 2*:
+``` cpp
+int f(const int i[10])
+  post(r : r == i[0]);  // error: i has type const int * (not int* const).
+```
+— *end example*]
+— *end note*]
+[*Note 5*: The function contract assertions of a function are evaluated
+even when invoked indirectly, such as through a pointer to function or a
+pointer to member function. A pointer to function, pointer to member
+function, or function type alias cannot have a
+*function-contract-specifier-seq* associated directly with
+it. — *end note*]
+The function contract assertions of a function are considered to be
+*needed* [[temp.inst]] when
+- the function is odr-used [[basic.def.odr]] or
+- the function is defined.
+[*Note 6*:
+Overload resolution does not consider *function-contract-specifier*s
+[[temp.deduct]], [[temp.inst]].
+[*Example 3*:
+``` cpp
+template <typename T>  void f(T t) pre( t == "" );
+template <typename T>  void f(T&& t);
+void g()
+{
+  f(5);     // error: ambiguous
+}
+```
+— *end example*]
+— *end note*]
+### Referring to the result object <a id="dcl.contract.res">[[dcl.contract.res]]</a>
+``` bnf
+attributed-identifier:
+  identifier attribute-specifier-seqₒₚₜ
+```
+``` bnf
+result-name-introducer:
+  attributed-identifier ':'
+```
+The *result-name-introducer* of a *postcondition-specifier* is a
+declaration. The *result-name-introducer* introduces the *identifier* as
+the name of a *result binding* of the associated function. If a
+postcondition assertion has a *result-name-introducer* and the return
+type of the function is cv `void`, the program is ill-formed. A result
+binding denotes the object or reference returned by invocation of that
+function. The type of a result binding is the return type of its
+associated function. The optional *attribute-specifier-seq* of the
+*attributed-identifier* in the *result-name-introducer* appertains to
+the result binding so introduced.
+[*Note 1*: An *id-expression* that names a result binding is a `const`
+lvalue [[expr.prim.id.unqual]]. — *end note*]
+[*Example 1*:
+``` cpp
+int f()
+  post(r : r == 1)
+{
+  return 1;
+}
+int i = f();    // Postcondition check succeeds.
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+struct A {};
+struct B {
+  B() {}
+  B(const B&) {}
+};
+template <typename T>
+T f(T* const ptr)
+  post(r: &r == ptr)
+{
+  return {};
+}
+int main() {
+  A a = f(&a);  // The postcondition check can fail if the implementation introduces
+                // a temporary for the return value[class.temporary].
+  B b = f(&b);  // The postcondition check succeeds, no temporary is introduced.
+}
+```
+— *end example*]
+When the declared return type of a non-templated function contains a
+placeholder type, a *postcondition-specifier* with a
+*result-name-introducer* shall be present only on a definition.
+[*Example 3*:
+``` cpp
+auto g(auto&)
+  post (r: r >= 0);     // OK, g is a template.
+auto h()
+  post (r: r >= 0);     // error: cannot name the return value
+auto k()
+  post (r: r >= 0)      // OK
+{
+  return 0;
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa