feat: gleam language support (#3)

Author: bajrangCoder

plugin.zip

@@ -23,6 +23,7 @@ Adds CodeMirror language support for languages that are not bundled with Acode.
 - Pkl (`.pkl`)
 - Svelte (`.svelte`)
 - WGSL (`.wgsl`)
+- Gleam (`.gleam`)
 
 Community modes are registered only when Acode does not already provide a mode
 with the same name. Languages already covered by Acode's

readme.md

@@ -402,3 +402,89 @@ for (const sample of gitattributesSamples) {
 }
 
 console.log(`Validated ${gitattributesSamples.length} GitAttributes parser fixtures.`);
+
+// Test Gleam Parser
+const { parser: gleamParser } = await bundledRequire(
+	"src/languages/gleam/parser.js",
+	"acode-gleam-parser-test.cjs",
+);
+
+const gleamSamples = [
+	{
+		name: "Gleam comments, imports, types and functions",
+		source: `//// This is a module comment
+/// This is a doc comment
+// This is a line comment
+
+@target(javascript)
+import wibble/wobble.{type MyType, my_value}
+
+pub type MyResult(a) {
+  Ok(a)
+  Error(Nil)
+}
+
+pub fn main() -> Nil {
+  let x = 123
+  let f = 3.14
+  let s = "hello"
+  let b = True
+  let _discarded = False
+  io.println(s)
+  case x {
+    _ -> Nil
+  }
+  let list = [1, 2]
+  let tuple = #(1, 2)
+  let bits = <<1, 2>>
+}
+`,
+		nodes: [
+			"ModuleComment",
+			"DocComment",
+			"LineComment",
+			"Attribute",
+			"TypeName",
+			"Identifier",
+			"String",
+			"Integer",
+			"Float",
+			"True",
+			"False",
+			"Nil",
+			"FunctionDefinition",
+			"FunctionCall",
+			"Block",
+			"Parenthesized",
+			"Bracketed",
+			"BitArray",
+		],
+	},
+];
+
+for (const sample of gleamSamples) {
+	const tree = gleamParser.parse(sample.source);
+	const names = new Set();
+	const errors = [];
+
+	tree.iterate({
+		enter(node) {
+			names.add(node.name);
+			if (node.type.isError) {
+				errors.push([node.from, node.to]);
+			}
+		},
+	});
+
+	// Print all parsed node names to inspect them
+	console.log("Parsed Gleam nodes:", [...names]);
+
+	assert.equal(errors.length, 0, `${sample.name} produced parse errors`);
+	assert.equal(tree.length, sample.source.length, `${sample.name} was not fully parsed`);
+	for (const node of sample.nodes) {
+		assert(names.has(node), `${sample.name} did not produce ${node}`);
+	}
+}
+
+console.log(`Validated ${gleamSamples.length} Gleam parser fixtures.`);
+

scripts/test-parser.mjs

@@ -69,6 +69,7 @@ async function test() {
 		"wgsl",
 		"ejs",
 		"gitattributes",
+		"gleam",
 	];
 
 	assert.deepEqual([...modes.keys()], expectedNames);
@@ -126,6 +127,7 @@ message:
 		wgsl: "@vertex fn main() -> @builtin(position) vec4f { return vec4f(); }",
 		ejs: "<% if (user) { %>\n<h2><%= user.name %></h2>\n<% } %>",
 		gitattributes: "# comment\n*.txt text eol=lf\n",
+		gleam: "pub fn main() { Nil }\n",
 	};
 
 	for (const [name, source] of Object.entries(samples)) {

scripts/test-plugin-runtime.cjs

@@ -0,0 +1,159 @@
+@top SourceFile { Element* }
+
+@precedence {
+  def,
+  call,
+  importAlias
+}
+
+Element {
+  ModuleComment |
+  DocComment |
+  LineComment |
+  Attribute |
+  String |
+  Float |
+  Integer |
+  Discard |
+  ImportStatement |
+  FunctionDefinition |
+  FunctionCall |
+  As | Assert | Case | Const | Echo | Else | Fn | If |
+  Let | Opaque | Panic | Pub | Todo | Type | Use |
+  True | False | Nil |
+  TypeName |
+  Identifier |
+  Operator |
+  Punctuation |
+  divOp |
+  dotOp |
+  Block |
+  Parenthesized |
+  Bracketed |
+  BitArray
+}
+
+Block { "{" Element* "}" }
+Parenthesized { "(" Element* ")" }
+Bracketed { "[" Element* "]" }
+BitArray { "<<" Element* ">>" }
+
+Attribute {
+  "@" Identifier !call "(" Element* ")" |
+  "@" Identifier
+}
+
+FunctionDefinition {
+  Fn !def Identifier
+}
+
+FunctionCall {
+  Identifier !call Parenthesized
+}
+
+ImportStatement {
+  !importAlias Import ModulePath (dotOp UnqualifiedImports)? (As (Identifier | Discard))?
+}
+
+ModulePath {
+  Identifier (!call divOp Identifier)*
+}
+
+UnqualifiedImports {
+  "{" (UnqualifiedImport ("," UnqualifiedImport)* ","?)? "}"
+}
+
+UnqualifiedImport {
+  Type? TypeName (As TypeName)? |
+  Identifier (As Identifier)?
+}
+
+As { @specialize<Identifier, "as"> }
+Assert { @specialize<Identifier, "assert"> }
+Case { @specialize<Identifier, "case"> }
+Const { @specialize<Identifier, "const"> }
+Echo { @specialize<Identifier, "echo"> }
+Else { @specialize<Identifier, "else"> }
+Fn { @specialize<Identifier, "fn"> }
+If { @specialize<Identifier, "if"> }
+Import { @specialize<Identifier, "import"> }
+Let { @specialize<Identifier, "let"> }
+Opaque { @specialize<Identifier, "opaque"> }
+Panic { @specialize<Identifier, "panic"> }
+Pub { @specialize<Identifier, "pub"> }
+Todo { @specialize<Identifier, "todo"> }
+Type { @specialize<Identifier, "type"> }
+Use { @specialize<Identifier, "use"> }
+
+True { @specialize<TypeName, "True"> }
+False { @specialize<TypeName, "False"> }
+Nil { @specialize<TypeName, "Nil"> }
+
+divOp { @specialize<Operator, "/"> }
+dotOp { @specialize<Punctuation, "."> }
+
+@tokens {
+  spaces { $[ \t]+ }
+  newline { "\r"? "\n" }
+
+  ModuleComment { "////" ![\n\r]* }
+  DocComment { "///" ![\n\r]* }
+  LineComment { "//" ![\n\r]* }
+
+  String {
+    '"' ( "\\" _ | !["\\\n\r] )* '"'
+  }
+
+  Float {
+    $[0-9] $[0-9_]* "." $[0-9_]* ($[eE] $[+-]? $[0-9_]+)? |
+    "-" $[0-9] $[0-9_]* "." $[0-9_]* ($[eE] $[+-]? $[0-9_]+)?
+  }
+
+  Integer {
+    ("0x" | "0X") $[0-9a-fA-F_]+ |
+    ("0o" | "0O") $[0-7_]+ |
+    ("0b" | "0B") $[01_]+ |
+    $[0-9] $[0-9_]* |
+    "-" $[0-9] $[0-9_]*
+  }
+
+  Discard { "_" $[a-zA-Z0-9_]* }
+
+  TypeName { $[A-Z] $[a-zA-Z0-9_]* }
+
+  Identifier { $[a-z_] $[a-zA-Z0-9_]* }
+
+  Operator {
+    "<-" | "->" | "<=" | ">=" | "==" | "!=" |
+    "<=." | ">=." | "<." | ">." |
+    "+." | "-." | "*." | "/." |
+    "+" | "-" | "*" | "/" | "%" |
+    "&&" | "||" | "!" |
+    "<>" | "|>" | "=" | "|" | ".." |
+    "<" | ">"
+  }
+
+  Punctuation {
+    "," | "." | ":" | ";" | "#"
+  }
+
+  "@" "{" "}" "(" ")" "[" "]" "<<" ">>"
+
+  @precedence {
+    ModuleComment,
+    DocComment,
+    LineComment,
+    String,
+    Float,
+    Integer,
+    TypeName,
+    Discard,
+    Identifier,
+    Operator,
+    Punctuation
+  }
+}
+
+@skip { spaces | newline }
+
+@detectDelim

src/languages/gleam/gleam.grammar

@@ -0,0 +1,94 @@
+import { completeFromList } from "@codemirror/autocomplete";
+import {
+	delimitedIndent,
+	foldInside,
+	foldNodeProp,
+	indentNodeProp,
+	LanguageSupport,
+	LRLanguage,
+} from "@codemirror/language";
+import { styleTags, tags as t } from "@lezer/highlight";
+import { parser } from "./parser";
+
+const configuredParser = parser.configure({
+	props: [
+		styleTags({
+			ModuleComment: t.docComment,
+			DocComment: t.docComment,
+			LineComment: t.lineComment,
+			String: t.string,
+			Float: t.number,
+			Integer: t.number,
+			Discard: t.comment,
+			"FunctionDefinition/Identifier": t.function(t.definition(t.variableName)),
+			"FunctionCall/Identifier": t.function(t.variableName),
+			TypeName: t.typeName,
+			ModulePath: t.namespace,
+			Identifier: t.variableName,
+			"True False": t.bool,
+			Nil: t.null,
+			"As Assert Case Else If Import Let Pub Type Use Const Opaque": t.keyword,
+			Fn: t.definitionKeyword,
+			"Panic Todo Echo": t.controlKeyword,
+			Operator: t.operator,
+			Attribute: t.meta,
+			"( )": t.paren,
+			"[ ]": t.squareBracket,
+			"{ }": t.brace,
+			"<< >>": t.special(t.brace),
+			Punctuation: t.punctuation,
+		}),
+		indentNodeProp.add({
+			Block: delimitedIndent({ closing: "}" }),
+			Bracketed: delimitedIndent({ closing: "]" }),
+			Parenthesized: delimitedIndent({ closing: ")" }),
+			BitArray: delimitedIndent({ closing: ">>" }),
+		}),
+		foldNodeProp.add({
+			Block: foldInside,
+			Bracketed: foldInside,
+			Parenthesized: foldInside,
+			BitArray: foldInside,
+		}),
+	],
+});
+
+export const gleamLanguage = LRLanguage.define({
+	name: "gleam",
+	parser: configuredParser,
+	languageData: {
+		commentTokens: { line: "//" },
+		closeBrackets: { brackets: ["(", "[", "{", '"', "<<"] },
+		indentOnInput: /^\s*}$/,
+	},
+});
+
+const keywords = [
+	"as", "assert", "case", "const", "echo", "else", "fn", "if", "import",
+	"let", "opaque", "panic", "pub", "todo", "type", "use",
+];
+
+const builtinTypes = [
+	"Int", "Float", "String", "Bool", "Nil", "UtfCodepoint", "BitArray", "Result", "List",
+];
+
+const gleamCompletion = gleamLanguage.data.of({
+	autocomplete: completeFromList([
+		...keywords.map((label) => ({ label, type: "keyword" })),
+		...builtinTypes.map((label) => ({ label, type: "type" })),
+		{ label: "True", type: "constant" },
+		{ label: "False", type: "constant" },
+		{ label: "Nil", type: "constant" },
+	]),
+});
+
+export function gleam() {
+	return new LanguageSupport(gleamLanguage, [gleamCompletion]);
+}
+
+export const gleamMode = {
+	name: "gleam",
+	caption: "Gleam",
+	extensions: ["gleam"],
+	load: gleam,
+};