Comment fix.

Noticed only because I was searching the codebase for "materializeForSet".

Author: rjmccall

lib/SILGen/FormalEvaluation.h

@@ -148,23 +148,25 @@ class FormalEvaluationContext {
   void dump(SILGenFunction &SGF);
 };
 
-/// A scope associated with the beginning of the formal evaluation of an lvalue.
+/// A scope associated with the beginning of the evaluation of an lvalue.
 ///
-/// A formal evaluation of an lvalue occurs when emitting:
+/// The evaluation of an l-value is split into two stages: its formal
+/// evaluation, which evaluates any independent r-values embedded in the l-value
+/// expression (e.g. class references and subscript indices), and its formal
+/// access duration, which delimits the span of time for which the referenced
+/// storage is actually accessed.
 ///
-///   1. accessors.
-///   2. getters.
-///   3. materializeForSets.
+/// Note that other evaluations can be interleaved between the formal evaluation
+/// and the beginning of the formal access.  For example, in a simple assignment
+/// statement, the left-hand side of the assignment is first formally evaluated
+/// as an l-value, then the right-hand side is evaluated as an r-value, and only
+/// then does the write access begin to the l-value.
 ///
-/// for lvalues. The general form of such an evaluation is:
-///
-///   formally evaluate the lvalue "x" into memory
-///   begin formal access to "x"
-///   end formal access to "x"
-///   ... *more formal access*
-///   begin formal access to "x"
-///   end formal access to "x"
-///   end formal evaluation of lvalue into memory
+/// Note also that the formal evaluation of an l-value will sometimes require
+/// its component l-values to be formally accessed.  For example, the formal
+/// access of the l-value `x?.prop` will initiate an access to `x` immediately
+/// because the downstream evaluation must be skipped if `x` has no value, which
+/// cannot be determined without beginning the access.
 ///
 /// *NOTE* All formal access contain a pointer to a cleanup in the normal
 /// cleanup stack. This is to ensure that when SILGen calls