It looks to be a variant of Design by Contract. DbC was described by Bertrand Meyer in his book Object-Oriented Software Construction. The basic idea of DbC is that there exist Contracts between subroutines, objects, and types, which basically guarantee that IFF the user of an abstraction fulfills their contract, THEN the provider of the abstraction guarantees that it will fulfill its contract.
Pragmatically, this allows to remove a lot of redundant error checking and defensive code, since it is very clear who is responsible for what. For example, in a subroutine, the callee does not have to check that arguments are valid because the contract says the caller is only allowed to pass valid arguments. In turn, the caller does not need to check the return value, since the contract says that if the arguments are valid, so is the return value.
If the contracts are actually recorded in the code proper, instead of just documentation, they can be automatically checked, which actually improves robustness even though the redundant checking has been removed.
Bertrand Meyer implemented DbC in his programming language Eiffel. In Eiffel, every subroutine can state its preconditions and postconditions and the compiler will automatically insert code that checks the preconditions before entering the subroutine, and the postconditions before returning from the subroutine. Likewise, classes can specify invariants about their instances, and the compiler will automatically insert checks after the postconditions checks to make sure an object always satisfies its invariants after a subroutine call. (Invariants may be violated while a subroutine is executing, but as soon as the subroutine is finished, the object must be in a valid state.)
Over time, there have been Contract Frameworks developed for many different programming languages (e.g. Boost.Contract for C++), and a few other languages with specific language-integration of DbC have appeared (e.g. D, Cobra (both also support language-integrated unit tests, and Cobra also language-integrated documentation), Spec♯, Sing♯, M♯).
Traditionally, Contract Systems, whether as libraries or integrated into the language, have worked at runtime. Microsoft's Spec♯ was, to my knowledge, the first system that tried to prove and disprove contracts at compile time. This was later extracted in the CodeContracts.NET library and shipped as part of .NET and Visual Studio.
Native language support for DbC in C++ may actually appear as early as C++2a.