Support reconfiguration of an LRLanguage's language data

FEATURE: `LRLanguage.reconfigure` now supports changing the language data associated
with the language.

See https://discuss.codemirror.net/t/dash-separated-kebab-case-selection-too-inclusive/9619

Author: marijnh

src/language.ts

@@ -166,8 +166,11 @@ function topNodeAt(state: EditorState, pos: number, side: -1 | 0 | 1) {
 /// [LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser)
 /// parsers.
 export class LRLanguage extends Language {
-  private constructor(data: Facet<{[name: string]: any}>, readonly parser: LRParser, name?: string) {
-    super(data, parser, [], name)
+  private constructor(data: Facet<{[name: string]: any}>,
+                      readonly parser: LRParser,
+                      private languageData: {[name: string]: any} | null,
+                      name?: string) {
+    super(data, parser, languageData ? [data.of(languageData)] : [], name)
   }
 
   /// Define a language from a parser.
@@ -182,16 +185,29 @@ export class LRLanguage extends Language {
     /// to register for this language.
     languageData?: {[name: string]: any}
   }) {
-    let data = defineLanguageFacet(spec.languageData)
+    let data = defineLanguageFacet()
     return new LRLanguage(data, spec.parser.configure({
       props: [languageDataProp.add(type => type.isTop ? data : undefined)]
-    }), spec.name)
+    }), spec.languageData || null, spec.name)
   }
 
   /// Create a new instance of this language with a reconfigured
-  /// version of its parser and optionally a new name.
-  configure(options: ParserConfig, name?: string): LRLanguage {
-    return new LRLanguage(this.data, this.parser.configure(options), name || this.name)
+  /// version of its parser, language data, and name.
+  ///
+  /// When `languageData` is given, any property set to `undefined`
+  /// in it will be removed from the language's
+  /// [data](#state.EditorState.languageDataAt), any other property
+  /// is added.
+  configure(options: ParserConfig & {languageData?: {[name: string]: any}}, name?: string): LRLanguage {
+    let {languageData} = this
+    if (options.languageData) {
+      languageData = {}
+      for (let prop in options.languageData)
+        if (options.languageData[prop] !== undefined) languageData[prop] = options.languageData[prop]
+      for (let prop in this.languageData)
+        if (!(prop in options.languageData)) languageData[prop] = this.languageData[prop]
+    }
+    return new LRLanguage(this.data, this.parser.configure(options), languageData, name || this.name)
   }
 
   get allowsNesting() { return this.parser.hasWrappers() }

src/stream-parser.ts

@@ -91,14 +91,14 @@ export class StreamLanguage<State> extends Language {
   topNode: NodeType
 
   private constructor(parser: StreamParser<State>) {
-    let data = defineLanguageFacet(parser.languageData)
+    let data = defineLanguageFacet()
     let p = fullParser(parser), self: StreamLanguage<State>
     let impl = new class extends Parser {
       createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly {from: number, to: number}[]) {
         return new Parse(self, input, fragments, ranges)
       }
     }
-    super(data, impl, [], parser.name)
+    super(data, impl, parser.languageData ? [data.of(parser.languageData)] : [], parser.name)
     this.topNode = docID(data, this)
     self = this
     this.streamParser = p

test/test-language.ts

@@ -0,0 +1,34 @@
+import ist from "ist"
+import {LRLanguage, syntaxTree} from "@codemirror/language"
+import {EditorState} from "@codemirror/state"
+import {parser} from "@lezer/javascript"
+
+describe("LRLanguage", () => {
+  it("parses the document", () => {
+    let lang = LRLanguage.define({name: "js", parser})
+    let state = EditorState.create({doc: "x = 2", extensions: lang})
+    ist(syntaxTree(state).topNode.name, "Script")
+  })
+
+  it("can be reconfigured", () => {
+    let lang = LRLanguage.define({name: "js", parser})
+    let lang2 = lang.configure({dialect: "jsx"})
+    let state = EditorState.create({doc: "x = <foo/>", extensions: lang2})
+    ist(syntaxTree(state).resolve(6).name, "JSXIdentifier")
+  })
+
+  it("associates language data", () => {
+    let lang = LRLanguage.define({name: "js", parser, languageData: {foo: 22}})
+    let state = EditorState.create({extensions: lang})
+    ist(state.languageDataAt("foo", 0).join(","), "22")
+  })
+
+  it("can reconfigure associated language data", () => {
+    let lang = LRLanguage.define({name: "js", parser, languageData: {foo: 22, bar: 10}})
+    let lang2 = lang.configure({languageData: {foo: undefined, baz: 11}})
+    let state = EditorState.create({extensions: lang2})
+    ist(state.languageDataAt("foo", 0).length, 0)
+    ist(state.languageDataAt("bar", 0).join(","), "10")
+    ist(state.languageDataAt("baz", 0).join(","), "11")
+  })
+})