[css-values-4] Serialization rules were pretending there was a distinction between math functions and calculation trees, but per spec there's not. Also define calc-operator node for usage in some spots.

Author: tabatkins

css-values-4/Overview.bs

@@ -3284,11 +3284,16 @@ Internal Representation</h3>
 
 	The [=internal representation=] of a [=math function=]
 	is a <dfn export>calculation tree</dfn>:
-	a tree of operator nodes,
-	such as Sum, Product, Min, or Cos,
-	with plain values
-	(numeric values, such as numbers, dimensions, and percentages,
-	and non-math functions that resolve to a numeric type) at the leaves.
+	a tree where the branch nodes are <dfn export for="calculation tree">operator nodes</dfn>
+	corresponding either to [=math functions=]
+	(such as Min, Cos, Sqrt, etc)
+	or to operators in a [=calculation=]
+	(Sum, Product, Negate, and Invert, the <dfn for="calculation tree">calc-operator nodes</dfn>),
+	and the leaf nodes
+	are either numeric values
+	(such as numbers, dimensions, and percentages)
+	or non-[=math functions=] that resolve to a numeric type.
+
 	[=Math functions=] are turned into [=calculation trees=]
 	depending on the function:
 
@@ -3298,7 +3303,7 @@ Internal Representation</h3>
 			is the result of [=parsing a calculation=] from its argument.
 		: any other [=math function=]
 		:: The [=internal representation=]
-			is an operator node with the same name as the function,
+			is an [=operator node=] with the same name as the function,
 			whose children are the result of [=parsing a calculation=]
 			from each of the function's arguments,
 			in the order they appear.
@@ -3308,7 +3313,7 @@ Internal Representation</h3>
 		To <dfn export lt="parse a calculation|parsing a calculation">parse a calculation</dfn>,
 		given a [=calculation=] |values|
 		represented as a list of [=component values=],
-		and returning a tree of operator nodes:
+		and returning a [=calculation tree=]:
 
 		1. Discard any <<whitespace-token>>s from |values|.
 
@@ -3397,14 +3402,11 @@ Simplification</h4>
 				expressed in the value's [=canonical unit=].
 			2. Otherwise, return |root|.
 
-		2. At this point, |root| is an operator node.
+		2. At this point, |root| is an [=operator node=].
 			[=Simplify=] all the children of |root|.
 
-		3. If |root| is a
-			Min, Max, Clamp,
-			Sin, Cos, Tan,
-			Asin, Acos, Atan, Atan2,
-			Pow, Sqrt, or Hypot node,
+		3. If |root| is an [=operator node=]
+			that's not one of the [=calc-operator nodes=],
 			and all of its children are numeric values
 			with enough information to computed the operation |root| represents,
 			return the result of running |root|'s operation
@@ -3584,8 +3586,7 @@ Serialization</h3>
 	<div algorithm>
 		To <dfn export>serialize a math function</dfn> |fn|:
 
-		1. If |fn| is a ''calc()'' function,
-			and the root of the [=calculation tree=] it represents
+		1. If the root of the [=calculation tree=] |fn| represents
 			is a numeric value
 			(number, percentage, or dimension),
 			and the serialization being produced is of a [=computed value=] or later,
@@ -3607,14 +3608,19 @@ Serialization</h3>
 			3. Append " / 0)" to |s|,
 				and return |s|.
 
-		3. Let |s| be a [=string=] that initially contains
-			the |fn|'s name
-			(such as "calc", "sin", etc)
+		3. If the [=calculation tree’s=] root node is a numeric value,
+			or a [=calc-operator node=],
+			let |s| be a string initially containing "calc(".
+
+			Otherwise,
+			let |s| be a string initially containing the name of the root node,
+			lowercased
+			(such as "sin" or "max"),
 			followed by a "(" (open parenthesis).
 
-		4. For each comma-separated [=calculation=] argument of |fn|,
+		4. For each child of the root node,
 			[=serialize the calculation tree=].
-			If a result of this starts with a "(" (open parenthesis)
+			If a result of this serialization starts with a "(" (open parenthesis)
 			and ends with a ")" (close parenthesis),
 			remove those characters from the result.
 			[=string/Concatenate=] all of the results