The actual change to the wording of `assert` that I intended in the previous CL.

docs/language/dartLangSpec.tex

 \documentclass{article}
 \usepackage{epsfig}
 \usepackage{color}
 \usepackage{dart}
 \usepackage{bnf}
 \usepackage{hyperref}
 \usepackage{lmodern}
 \usepackage[T1]{fontenc}
 \newcommand{\code}[1]{{\sf #1}}
 \title{Dart Programming Language  Specification  \\
@@ skipping 6719 matching lines @@
 \end{itemize}
 
 
 \LMHash{}
 It is a compile-time error if a yield-each statement appears in a function that is not a generator function.
 
 \LMHash{}
 Let $T$ be the static type of $e$ and let $f$ be the immediately enclosing function.  It is a static type warning if $T$ may not be assigned to the declared return type of $f$.  If $f$ is synchronous it is a static  type warning if $T$ may not be assigned to \code{Iterable}.  If $f$ is asynchronous it is a static  type warning if $T$ may not be assigned to \code{Stream}.
 
 
-\subsection{ Assert}
+\subsection{Assert}
 \LMLabel{assert}
 
 \LMHash{}
 An {\em assert statement} is used to disrupt normal execution if a given boolean condition does not hold.
 
 \begin{grammar}
 {\bf assertStatement:}
     assertion `{\escapegrammar ;}'
     .
 {\bf assertion:}
@@ skipping 16 matching lines @@
 and completes in the same way as the assertion.
 
 \LMHash{}
 In production mode the assertion has no effect
 and its execution immediately completes normally (\ref{completion}).
 In checked mode,
 execution of an assertion \code{\ASSERT{}($c$, $e$)} proceeds as follows:
 
 \LMHash{}
 The expression $c$ is evaluated to an object $o$.
-If the class of $o$ is not a subtype of \code{Function} then
-let $r$ be $o$.
-Otherwise,
-if the assertion occurs in the initializer list of a \CONST{} constructor,
-then we say that the assertion failed,
-otherwise let $r$ be the result of invoking $o$ with no arguments.
-It is a dynamic type error if $o$ is not of type \code{bool} or of type \code{Function}, or if $r$ is not of type \code{bool}.
-If $r$ is \FALSE{}, we say that the assertion failed.
-If $r$ is \TRUE{}, we say that the assertion succeeded.
-If the assertion succeeded, execution of the assert statement completes normally (\ref{completion}).
-If the assertion failed, $e$ is evaluated to an object $m$.
+If the class of $o$ is a subtype of \code{Function}
+and the assertion does not occur in the initializer list of a \CONST{} constructor,
+then let $r$ be the result of invoking $o$ with no arguments.
+Otherwise let $r$ be $o$.
+It is a dynamic type error if $r$ is not of type \code{bool}.

[eernst, 2017/07/10 14:04:54]

`\commentary{Hence, it is a compile-time error if that situation arises during
execution of an assertion in a \CONST{} constructor invocation.}` ;-)

[Lasse Reichstein Nielsen, 2017/07/11 09:51:48]

Done.

+If $r$ is \TRUE{}, execution of the assert statement completes normally (\ref{completion}).
+Otherwise, $e$ is evaluated to an object $m$.

[eernst, 2017/07/10 14:04:54]

It's probably easier for the reader to get this right if we prevent `Otherwise`
from covering only that sentence. We could use a semicolon: `Otherwise .. $m$;
then the execution..`.

[Lasse Reichstein Nielsen, 2017/07/11 09:51:48]

I don't feel confident using a semicolon like that, so I went with "and then".

 Then the execution of the assert statement throws (\ref{completion}) an \code{AssertionError} containing $m$ and with a stack trace corresponding to the current execution state at the \ASSERT{} statement.
 
 \LMHash{}
 It is a static type warning if the type of $e$ may not be assigned to either
 \code{bool} or $() \rightarrow$ \code{bool}.
 If the assertion occurs in a \CONST{} constructor initializer list, it is a static type warning if the type of $e$ may not be assigned to \code{bool}.
 
 \rationale{Why is this a statement, not a built in function call? Because it is handled magically so it has no effect and no overhead in production mode. Also, in the absence of final methods. one could not prevent it being overridden (though there is no real harm in that).  It cannot be viewed as a function call that is being optimized away because the argument might have side effects.
 }
 
@@ skipping 1440 matching lines @@
 
 The invariant that each normative paragraph is associated with a line
 containing the text \LMHash{} should be maintained.  Extra occurrences
 of \LMHash{} can be added if needed, e.g., in order to make
 individual \item{}s in itemized lists addressable.  Each \LM.. command
 must occur on a separate line.  \LMHash{} must occur immediately
 before the associated paragraph, and \LMLabel must occur immediately
 after the associated \section{}, \subsection{} etc.
 
 ----------------------------------------------------------------------