[css-values-5][css-mixins-1] Exclude : from first if() production. Rename 'comma-containing production' to 'free-form production', slightly rework definition to be clearer. #12487

Author: tabatkins

css-mixins-1/Overview.bs

@@ -488,8 +488,8 @@ is the real element at the root of the [=calling context=] stack.
 </wpt>
 
 <div class='example'>
-	A [=comma-containing productions|comma-containing value=]
-	may be passed as a single argument
+	A [=free-form production|comma-containing value=]
+	can be passed as a single argument
 	by wrapping the value in curly braces, <code>{}</code>:
 
 	<pre class='lang-css'>
@@ -2617,7 +2617,7 @@ given a <<declaration-value>> |argument|:
 
 		<div class=note>
 		See [[css-values-5#component-function-commas]] for more information
-		on [=comma-containing productions=].
+		on [=free-form productions=].
 		</div>
 </div>
 

css-values-5/Overview.bs

@@ -122,33 +122,42 @@ Functional Notation Definitions</h3>
 Commas in Function Arguments</h4>
 
 	[=Functional notation=] often uses commas
-	to separate parts of its internal grammar.
+	to separate parts of its internal grammar,
+	and occasionally other syntax
+	(such as <code>:</code> or <code>;</code> in ''if()'').
 	However, some functions
 	(such as ''mix()'')
 	allow values that, themselves,
-	can contain commas.
+	could contain these argument-separating tokens.
 	These values
 	(currently <<whole-value>>, <<declaration-value>>, and <<any-value>>)
-	are <dfn export>comma-containing productions</dfn>.
+	are <dfn export>free-form productions</dfn>.
 
 	To accommodate these sorts of grammars unambiguously,
-	the [=comma-containing productions=] can be optionally wrapped in curly braces {}.
-	These braces are syntactic, not part of the actual value.
-	Specifically:
-
-	* A [=comma-containing production=] can either start with a "{" token, or not.
-	* If it does not start with a "{" token,
-		then it cannot contain commas or {} blocks,
-		in addition to whatever specific restrictions it defines for itself.
+	the [=free-form productions=] can be optionally wrapped in curly braces {}.
+	These braces are syntactic, not part of the actual value,
+	and only serve to explicitly indicate the bounds of the production.
+	A [=free-form production=] can either
+	(after optional whitespace)
+	start with a <<{-token>>, or not:
+
+	: If it does not start with a "{" token
+	::
+		The production does not match any top-level commas or {} blocks.
 		(The production stops parsing at that point,
 		so the comma or {} block is matched by the next grammar term instead;
 		probably the function's own argument-separating comma.)
-	* If it does start with a "{" token,
-		then the production matches just the {} block that the "{" token opens.
+		Individual usages of the production can define additional tokens
+		that are similarly restricted from matching at the top-level.
+	: If it does start with a "{" token
+	::
+		The production matches just the {} block that the "{" token opens.
 		It represents the <em>contents</em> of that block,
-		and applies whatever specific restrictions it defines for itself
-		to those contents,
-		ignoring the {} block wrapper.
+		ignoring the {} block wrapper itself.
+
+	Note: General restrictions defined for a particular [=free-form production=],
+	like <<declaration-value>> not matching <<semicolon-token>>s,
+	apply regardless of whether it's {}-wrapped or not.
 
 	<div class="example">
 		For example, the grammar of the ''random-item()'' function is:
@@ -194,7 +203,7 @@ Commas in Function Arguments</h4>
 		either ''Times, serif'', or ''sans-serif'', or ''monospace''.
 
 		However, this {}-wrapping is <em>only</em> allowed for some function arguments--
-		those defined as [=comma-containing productions=].
+		those defined as [=free-form productions=].
 		It's not valid for any other productions;
 		if you use {} around other function arguments,
 		it'll just fail to match the function's grammar
@@ -217,24 +226,24 @@ Commas in Function Arguments</h4>
 
 	[=Functional notations=] are serialized without {} wrappers whenever possible.
 
-	The following generic productions are [=comma-containing productions=]:
+	The following generic productions are [=free-form productions=]:
 
 	* <<any-value>>
 	* <<whole-value>>
 	* <<declaration-value>>
 
 	For legacy compat reasons,
 	the <<declaration-value>> defined for the fallback value of ''var()''
-	is a <dfn export>non-strict comma-containing production</dfn>.
+	is a <dfn export>non-strict free-form production</dfn>.
 	It ignores the rules restricting what it can contain
 	when it does not start with a "{" token:
 	it is allowed to contain commas and {} blocks.
-	It still follows the standard [=comma-containing production=] rules
+	It still follows the standard [=free-form production=] rules
 	when it <em>does</em> start with a "{" token, however:
 	the fallback is just the contents of the {} block,
 	and doesn't include the {} wrapper itself.
 
-	Other contexts <em>may</em> define that they use [=non-strict comma-containing productions=],
+	Other contexts <em>may</em> define that they use [=non-strict free-form productions=],
 	but it <em>should</em> be avoided unless necessary.
 
 <h3 id=boolean>
@@ -1605,6 +1614,12 @@ Conditional Value Selection: the ''if()'' notation</h3>
 		<dfn><<if-args-branch>></dfn> = <<declaration-value>> : <<declaration-value>>?
 	</pre>
 
+	In the above <<if-args-branch>> production,
+	the first <<declaration-value>>
+	excludes top-level <<colon-token>>s
+	as part of its [=free-form production=] restrictions
+	(alongside commas and curly braces).
+
 	<div algorithm>
 		To <dfn export>[=replace an arbitrary substitution function|replace an if() function=]</dfn>,
 		given a list of |arguments|: