Minor things

Author: cdoublev

__tests__/style.js

@@ -469,8 +469,9 @@ describe('<whole-value>', () => {
     test('valid', () => {
         const style = createStyleBlock()
         const valid = [
+            // Resolved at parse time
+            ['first-valid(1)', '1', 'opacity'],
             // Serialize the list of tokens
-            ['  /**/  first-valid(  /**/ 1e0 /**/  ', '1', 'opacity'],
             ['  /**/  mix(  0, 1, /**/ 1e0 /**/  ', 'mix(0, 1, 1)', 'opacity'],
             ['  /**/  toggle(  /**/ 1e0 /**/  ', 'toggle(1)', 'opacity'],
             // Nested inside itself

__tests__/stylesheet.js

@@ -61,7 +61,7 @@ function createStyleSheet(rules = '', properties = {}) {
  *
  * This abstraction is not great but probably the best way to avoid increasing
  * code complexity in tests, until first-valid() can be replaced with another
- * <whole-value> substitution that do not require resolved at parse time.
+ * <whole-value> substitution that do not require to be resolved at parse time.
  */
 function normalizeText(text) {
     return text
@@ -1069,7 +1069,7 @@ describe('CSS grammar - syntax', () => {
     })
     test('nested - declaration with a value containing a bad token', () => {
         // It is always invalid... except with forgiving grammar?
-        const { cssRules: [nested] } = createStyleSheet(`
+        const styleSheet = createStyleSheet(`
             style {
                 color: var(--custom) "\n;
                 color: var(--custom) url(bad .url);
@@ -1080,46 +1080,46 @@ describe('CSS grammar - syntax', () => {
                 style {}
             }
         `)
-        expect(nested.cssText).toBe('style { & style {} }')
+        expect(styleSheet.cssRules[0].cssText).toBe('style { & style {} }')
     })
     test('nested - declaration not for a custom property with a value containing a positioned {}-block', () => {
         // It is always consumed as a rule
-        const { cssRules: [nested] } = createStyleSheet(`
+        const styleSheet = createStyleSheet(`
             style {
                 color: {} var(--custom);
                 color:var(--custom) {}
                 color: ] {}
                 style:hover {}
             }
         `)
-        expect(nested.cssText).toBe('style { & style:hover {} }')
+        expect(styleSheet.cssRules[0].cssText).toBe('style { & style:hover {} }')
     })
     test('nested - declaration for a custom property with a value containing a positioned {}-block', () => {
         // It is never consumed as a qualified rule in a nested context
-        const { cssRules: [nested] } = createStyleSheet(`
+        const styleSheet = createStyleSheet(`
             style {
                 --custom-1: {} 1;
                 --custom-2: 1 {};
                 --custom-3: ] {}
                 style:hover {}
             }
         `)
-        expect(nested.cssText).toBe('style { --custom-1: {} 1; --custom-2: 1 {}; }')
+        expect(styleSheet.cssRules[0].cssText).toBe('style { --custom-1: {} 1; --custom-2: 1 {}; }')
     })
 })
 
 describe('CSS grammar - semantic', () => {
     // Style sheet contents
     test('top-level - invalid contents', () => {
-        const { cssRules } = createStyleSheet(`
+        const styleSheet = createStyleSheet(`
             @charset "utf-8";
             @namespace svg "http://www.w3.org/2000/svg" {}
             @media;
             @annotation {}
             @top-left {}
             0% {}
         `)
-        expect(cssRules).toHaveLength(0)
+        expect(styleSheet.cssRules).toHaveLength(0)
     })
     test('top-level - opening and ending HTML comment tokens', () => {
 

__tests__/value.js

@@ -779,10 +779,10 @@ describe('functions', () => {
     })
     test('valid', () => {
         const valid = [
-            // Unclosed (parse error)
-            ['fn()', 'fn(', 'fn()'],
             // Case-insensitive name
             ['fn(a)', 'FN(a)', 'fn(a)'],
+            // Unclosed (parse error)
+            ['fn()', 'fn(', 'fn()'],
             // Comma-containing production
             ['fn([<declaration-value>?]#)', 'fn({}, , { a }, { , }, {{}})', 'fn(,, a, {,}, {{}})'],
             ['fn(<declaration-value>?, a)', 'fn(, a)'],

doc/parse/parser.md

@@ -57,7 +57,7 @@ An **ambiguity** exists when there are multiple derivations for the same input.
 
 A canonical example to illustrate a parsing ambiguity is the grammar of math operations, which involves associativity and precedence rules. The priorities associated with these rules are important because the (semantic) result could be different without them.
 
-As in math operations, left associativity is usually expected for parsing programming languages: the parser must read the input from left to right: `1 - 2 + 3` must be interpreted to `2` instead of `4`. But to interpret `1 + 2 * 3` to `7` instead of `9`, precedence rules must be hard-coded with a more complex value definition than `<calc-value> [['+' | '-' | '*' | '/'] <calc-value>]*`.
+As in math operations, left associativity is usually expected for parsing programming languages: the parser must read the input from left to right: `1 - 2 + 3` must be interpreted to `2` instead of `4`. But to interpret `1 + 2 * 3` to `7` instead of `9`, precedence rules must be encoded with a more complex value definition than `<calc-value> [['+' | '-' | '*' | '/'] <calc-value>]*`.
 
 For grammars that remain ambiguous, a priority must be decided, either ahead of time (statically), with the first, last, or longest match priority, or at parse time (dynamically), depending on the context.
 

lib/parse/grammar.js

@@ -237,7 +237,10 @@ function matchSimpleBlock(block, node, parser) {
     const { associatedToken, types, value } = block
     const { context, definition, input } = node
     if (types[0] === '<simple-block>' && associatedToken === definition.associatedToken) {
-        const match = parser.parseCSSValue(new Stream(value, input.source), definition.value, context)
+        const match = parser.parseCSSValue(
+            new Stream(value, input.source),
+            definition.value,
+            { ...context, block: context })
         if (match instanceof SyntaxError) {
             return match
         }

lib/parse/postprocess.js

@@ -422,8 +422,8 @@ function postParseDashedIdent(identifier) {
  *
  * It aborts parsing when the head uses an invalid <dashed-ident> name.
  */
-function postParseDashedFunctionHead(head, node, { parseCSSGrammar }) {
-    if (parseCSSGrammar(head[0].name, '<dashed-ident>', node.context)) {
+function postParseDashedFunctionHead(head, node, parser) {
+    if (parser.parseCSSGrammar(head[0].name, '<dashed-ident>', node.context)) {
         return head
     }
     return error(node)