Fix range and round properties of calculation function

Both was supposed to be set based on node.definition but were actually set based
on the substitution definition, and node.definition.range does not represent a
numeric range. Following dd2da38, the min and max boudaries default to the
min and max safe JS integers.

Author: cdoublev

lib/parse/replace.js

@@ -76,32 +76,41 @@ function getPercentageResolutionType({ definition: { name }, parent }) {
  */
 function replaceNumeric(node) {
 
+    const {
+        context,
+        definition: {
+            max = Number.MAX_SAFE_INTEGER,
+            min = Number.MIN_SAFE_INTEGER,
+            name,
+        },
+        input,
+        parent,
+    } = node
     const topLevel = !isProducedBy(node, '<calc-value>')
-    const { context, definition, input, parent } = node
     const token = input.next()
 
     if (token.types[0] !== '<function-token>') {
-        if (definition.name === '<number>' && topLevel) {
+        if (name === '<number>' && topLevel) {
             return replaceWithColorComponentKeyword(node)
         }
         return null
     }
 
     // <dimension> produced by a specific dimension type
-    if (definition.name === '<dimension>' && parent?.definition.type === 'non-terminal') {
+    if (name === '<dimension>' && parent?.definition.type === 'non-terminal') {
         return null
     }
 
-    for (const { definition, element, name } of substitutions.numeric) {
+    for (const fn of substitutions.numeric) {
 
         // Validate the grammar
-        if (isFailure(parseGrammar([token], { name: '<function-token>', range: name, type: 'token' }, context))) {
+        if (isFailure(parseGrammar([token], { name: '<function-token>', range: fn.name, type: 'token' }, context))) {
             continue
         }
-        if (element && !getRule(node)?.definition.elemental) {
+        if (fn.element && !getRule(node)?.definition.elemental) {
             return error(node)
         }
-        const match = parseGrammar(input, definition, node, 'lazy')
+        const match = parseGrammar(input, fn.definition, node, 'lazy')
         if (isFailure(match)) {
             return error(node)
         }
@@ -114,10 +123,9 @@ function replaceNumeric(node) {
             const type = getCalculationType(match, resolutionType)
 
             if (matchNumericType(type, replacedType, resolutionType)) {
-                const { name, range } = definition
                 return {
                     ...match,
-                    range,
+                    range: { max, min },
                     round: name === '<integer>',
                     types: [...match.types, '<calc-function>'],
                     value: simplifyCalculation(match, resolutionType, context.globalObject.devicePixelRatio),

test/value.js

@@ -1627,16 +1627,16 @@ describe('<calc()>', () => {
             value: list([one, { types: ['<calc-invert>'], value: two }], '*', ['<calc-product>']),
         })
         // Resolved calculation
-        assert.representation('<number>', 'calc(1)', {
+        assert.representation('<integer [-1,0]>', 'calc(1)', {
             name: 'calc',
-            range: undefined,
-            round: false,
+            range: { max: 0, min: -1 },
+            round: true,
             types: ['<function>', '<calc()>', '<calc-function>'],
             value: number(1, ['<calc-value>']),
         })
         assert.representation('<number>', 'calc(1 + 2)', {
             name: 'calc',
-            range: undefined,
+            range: { max: Number.MAX_SAFE_INTEGER, min: Number.MIN_SAFE_INTEGER },
             round: false,
             types: ['<function>', '<calc()>', '<calc-function>'],
             value: {