Refactorize context

The previous context model exposed the closest function and block, but did not
allow determining which was the closest. Representing a block is useless at the
moment because it has no semantic value, but it defines the token marking the
end of its value, which will be required in a future commit.

Overall, the new model is simpler, more functional and idiomatic.

Author: cdoublev

__tests__/value.js

@@ -867,20 +867,20 @@ describe('<declaration>', () => {
             '--custom: }',
             '--custom: !',
         ]
-        invalid.forEach(input => expect(parse('<declaration>', input, false)).toBeNull())
+        invalid.forEach(input => expect(parse('<declaration>', input, false, styleRule)).toBeNull())
     })
     test('representation', () => {
-        expect(parse('<declaration>', 'color: green !important', false)).toMatchObject({
+        expect(parse('<declaration>', 'color: green !important', false, styleRule)).toMatchObject({
             important: true,
             name: 'color',
             types: ['<declaration>'],
             value: keyword('green', ['<named-color>', '<color-base>', '<color>', 'color']),
         })
     })
     test('valid', () => {
-        expect(parse('<declaration>', '--custom:  /**/  {} 1e0 {} !important  /**/  '))
+        expect(parse('<declaration>', '--custom:  /**/  {} 1e0 {} !important  /**/  ', true, styleRule))
             .toBe('--custom: {} 1e0 {} !important')
-        expect(parse('<declaration>', '--custom:'))
+        expect(parse('<declaration>', '--custom:', true, styleRule))
             .toBe('--custom: ')
     })
 })
@@ -3160,7 +3160,8 @@ describe('<counter>', () => {
         })
     })
     test('valid', () => {
-        const context = { ...createContext(styleRule), declaration: { definition: { name: 'any-property' } } }
+        let context = createContext(styleRule)
+        context = { ...context, context, definition: { name: 'any-property', type: 'declaration' } }
         expect(parse('<counter>', 'counter(chapters, decimal)', true, context)).toBe('counter(chapters)')
         expect(parse('<counter>', 'counters(chapters, "-", decimal)', true, context)).toBe('counters(chapters, "-")')
     })
@@ -3183,7 +3184,8 @@ describe('<counter-style-name>', () => {
             .toMatchObject(customIdent('custom', ['<counter-style-name>']))
     })
     test('valid', () => {
-        const context = { ...createContext(styleRule), declaration: { definition: { name: 'any-property' } } }
+        let context = createContext(styleRule)
+        context = { ...context, context, definition: { name: 'any-property', type: 'declaration' } }
         expect(parse('<counter-style-name>', 'DECIMAL', true, context)).toBe('decimal')
         expect(parse('<counter-style-name>', 'NAME')).toBe('NAME')
     })
@@ -3222,22 +3224,24 @@ describe('<family-name>', () => {
         const invalid = [
             [
                 [
-                    { declaration: { definition: { name: 'font-family' } } },
-                    { declaration: { definition: { name: 'src' } } },
-                    { rule: { definition: { name: '@font-feature-values', type: 'rule' } } },
+                    [createContext(styleRule), 'font-family'],
+                    [createContext('@font-face'), 'src'],
+                    [createContext('@font-feature-values')],
                 ],
                 // <generic-family>, <system-family-name>
                 ['SERIF', 'caption'],
             ],
             [
-                [{ declaration: { definition: { name: 'voice-family' } } }],
+                [[createContext(styleRule), 'voice-family']],
                 // <gender>, preserve
                 ['MALE', 'preserve'],
             ],
         ]
         invalid.forEach(([contexts, inputs]) =>
-            contexts.forEach(context => {
-                context = { ...createContext(), ...context }
+            contexts.forEach(([context, name]) => {
+                if (name) {
+                    context = { ...context, context, definition: { name, type: 'declaration' } }
+                }
                 inputs.forEach(input => expect(parse('<family-name>', input, false, context)).toBeNull())
             }))
     })

lib/parse/arbitrary.js

@@ -1,5 +1,6 @@
 
 const { isBlock, isComma, isDelimiter, isWhitespace } = require('../utils/value.js')
+const { getFunction, getRule } = require('../utils/context.js')
 const { list, omitted } = require('../values/value.js')
 const Stream = require('./stream.js')
 const blocks = require('../values/blocks.js')
@@ -53,19 +54,11 @@ function matchAnyValue(input, restricted, stops = []) {
  * @returns {object}
  * @see {@link https://drafts.csswg.org/css-syntax-3/#typedef-block-contents}
  */
-function matchBlockContents({ context, input }, parser) {
-    if (context.rule) {
-        return parser.parseBlockContents(input, context)
+function matchBlockContents(node, parser) {
+    if (getRule(node)) {
+        return parser.parseBlockContents(node.input, node)
     }
-    return parser.parseStyleSheet(input, context)
-}
-
-/**
- * @param {object} node
- * @returns {boolean}
- */
-function isGeneralFunctionalNotation({ definition, input }) {
-    return !definition.name && !input.current.name.startsWith('--')
+    return parser.parseStyleSheet(node.input, node)
 }
 
 /**
@@ -74,8 +67,10 @@ function isGeneralFunctionalNotation({ definition, input }) {
  * @returns {SyntaxError|object[]|null}
  */
 function matchCommaContainingValue(node, match) {
-    const { context, input, parent } = node
-    if (context.function && !isGeneralFunctionalNotation(context.function)) {
+    const { input, parent } = node
+    const context = getFunction(node)
+    // Do not restrict functions defined with a general notation except custom function definitions
+    if (context && (context.definition.name || context.input.current.name.startsWith('--'))) {
         if (input.atEnd()) {
             return null
         }
@@ -90,7 +85,7 @@ function matchCommaContainingValue(node, match) {
             }
             return error(node)
         }
-        if (context.function.definition.name !== 'var') {
+        if (context.definition.name !== 'var') {
             return match(input, true)
         }
     }

lib/parse/grammar.js

@@ -8,6 +8,7 @@ const actions = require('./actions.js')
 const arbitrary = require('./arbitrary.js')
 const forgiving = require('../values/forgiving.js')
 const parseDefinition = require('./definition.js')
+const { type } = require('../utils/node.js')
 
 const states = {
     aborted: {},
@@ -191,7 +192,7 @@ function match(node, parser) {
         case 'block':
             return input.consume(matchBlock, node, parser)
         case 'forgiving':
-            return parser.parseCSSGrammarList(input, forgiving[name], { ...context, forgiving: true })
+            return parser.parseCSSGrammarList(input, forgiving[name], node)
         case 'function':
             return input.consume(matchFunction, node, parser)
         case 'omitted':
@@ -210,12 +211,9 @@ function match(node, parser) {
  * @returns {object|null}
  */
 function matchBlock(value, node, parser) {
-    const { context, definition, input } = node
+    const { definition, input } = node
     if (isBlock(value, definition.associatedToken)) {
-        const match = parser.parseCSSGrammar(
-            new Stream(value.value, input.source),
-            definition.value,
-            context)
+        const match = parser.parseCSSGrammar(new Stream(value.value, input.source), definition.value, node)
         if (isFailure(match)) {
             return match
         }
@@ -234,20 +232,16 @@ function matchFunction(value, node, parser) {
     if (value.types[0] !== '<function>') {
         return null
     }
-    const { context, definition, input } = node
-    const ctx = { ...context, function: node }
+    const { definition, input } = node
     if (definition.name) {
-        const match = parser.parseCSSGrammar(value.name, definition.name, ctx)
+        const match = parser.parseCSSGrammar(value.name, definition.name, node)
         if (isFailure(match)) {
             return match
         }
         value = { ...value, name: match.value }
     }
     if (definition.value) {
-        const match = parser.parseCSSGrammar(
-            new Stream(value.value, input.source),
-            definition.value,
-            ctx)
+        const match = parser.parseCSSGrammar(new Stream(value.value, input.source), definition.value, node)
         if (isFailure(match)) {
             return match
         }
@@ -549,6 +543,7 @@ function create(definition, input, context, parent = null) {
         location: input.index,
         parent,
         state: 'waiting',
+        type,
     }
     return actions.configure[definition.name]?.(node) ?? node
 }

lib/parse/intercept.js

@@ -1,4 +1,6 @@
 
+const { findContext } = require('../utils/context.js')
+
 /**
  * @param {SyntaxError} error
  * @param {object} node
@@ -8,8 +10,9 @@
  * It stops propagating an error resulting from parsing an item of a forgiving
  * selector list, to serialize the list with the invalid selector.
  */
-function interceptInvalidSelector(error, { context, input }) {
-    if (!context.strict && context.forgiving) {
+function interceptInvalidSelector(error, node) {
+    const { context, input, location } = node
+    if (!context.strict && findContext(node, node => node.definition.type === 'forgiving')) {
         input.moveToEnd()
         return input.data
     }
@@ -30,9 +33,10 @@ function interceptInvalidSelector(error, { context, input }) {
  * It stops propagating an error resulting from parsing a query in parens, to
  * fallback with <general-enclosed>.
  */
-function interceptQueryInParensError(error, { context, input, location }, parser) {
+function interceptQueryInParensError(error, node, parser) {
+    const { input, location } = node
     input.moveTo(location)
-    return parser.parseCSSGrammar(input, '<general-enclosed>', context, 'lazy') ?? error
+    return parser.parseCSSGrammar(input, '<general-enclosed>', node, 'lazy') ?? error
 }
 
 module.exports = {