fix: error messages

Author: verytactical

packages/pgen/compile.ts

@@ -39,7 +39,7 @@ type Context = {
 }
 type Compiler<T> = (ctx: Context) => T;
 
-const compileRule = ({ name, formals, body }: g.Rule): Compiler<{
+const compileRule = ({ name, formals, body, display }: g.Rule): Compiler<{
     name: string | undefined,
     expr: t.Statement,
     type: t.Statement,
@@ -50,7 +50,7 @@ const compileRule = ({ name, formals, body }: g.Rule): Compiler<{
 
     const { expr: exprCode, type: typeCode } = compileExpr(body)(ctx);
 
-    const bodyCode = compileFormals(name, formals, exprCode);
+    const bodyCode = compileFormals(name, formals, compileDisplay(display, exprCode));
 
     return {
         name: formals.length > 0 ? undefined : name,
@@ -69,6 +69,15 @@ const compileRule = ({ name, formals, body }: g.Rule): Compiler<{
     };
 };
 
+const compileDisplay = (display: g.Rule["display"], expr: t.Expression): t.Expression => {
+    if (!display) {
+        return expr;
+    }
+    const body = display.map(char => compileChar(char)).join('');
+    const value = JSON.parse(`"${body}"`);
+    return emitCall('named', [t.stringLiteral(value), expr]);
+};
+
 const compileFormals = (name: string, formals: readonly string[], bodyCode: t.Expression): t.Expression => {
     if (formals.length === 0) {
         return bodyCode;
@@ -216,10 +225,17 @@ const compileClass = ({ insensitive, negated, seqs }: g.Class): Compiler<ExprWit
     const children = seqs.map(seq => compileSeq(seq));
     const body = children.map(child => child.expr).join('');
     const types = children.map(child => child.type);
+    const expectables = t.arrayExpression(children.map(child => child.exp));
     return ewt(
         emitCall(
             'regex',
-            [t.stringLiteral(prefix + body), t.booleanLiteral(insensitive)],
+            [
+                t.stringLiteral(prefix + body),
+                negated
+                    ? emitCall('negateExps', [expectables])
+                    : expectables,
+                // t.booleanLiteral(insensitive)
+            ],
             [t.tsUnionType(types)]
         ),
         t.tsUnionType(types),
@@ -295,7 +311,7 @@ const compileCall = (node: g.Call): Compiler<ExprWithType> => ctx => {
     return ewt(wrapInRef(node.name, body), type);
 };
 
-type TypedString = { expr: string, type: t.TSType };
+type TypedString = { expr: string, type: t.TSType, exp: t.Expression };
 
 const compileChar = (node: g.Escape | g.Special | g.Char): string => {
     switch (node.$) {
@@ -309,16 +325,20 @@ const compileChar = (node: g.Escape | g.Special | g.Char): string => {
 const compileSeq = (node: g.Group | g.ClassChar | g.SpecialClass | g.Escape): TypedString => {
     switch (node.$) {
         case 'Group':
+            const from = compileSeq(node.from).expr;
+            const to = compileSeq(node.to).expr;
             return {
-                expr: compileSeq(node.from).expr + '-' + compileSeq(node.to).expr,
+                expr: from + '-' + to,
                 type: t.tsStringKeyword(),
+                exp: emitCall('ExpRange', [t.stringLiteral(from), t.stringLiteral(to)])
             };
         case 'ClassChar':
             return {
                 expr: node.value === '\\' || node.value === '\]'
                     ? `\\${node.value}`
                     : node.value,
                 type: t.tsLiteralType(t.stringLiteral(node.value)),
+                exp: emitCall('ExpString', [t.stringLiteral(node.value)])
             };
         default:
             return compileEscape(node);
@@ -330,18 +350,20 @@ const compileEscape = (node: g.Escape | g.Special | g.SpecialClass): TypedString
 
     const str = `"${expr}"`;
 
-    const type = (() => {
-        try {
-            return t.tsLiteralType(t.stringLiteral(JSON.parse(str)));
-        } catch (e) {
-            return t.tsStringKeyword();
-        }
-    })();
-
-    return {
-        expr,
-        type,
-    };
+    try {
+        const parsed = JSON.parse(str);
+        return {
+            expr,
+            type: t.tsLiteralType(t.stringLiteral(parsed)),
+            exp: emitCall('ExpString', [t.stringLiteral(parsed)])
+        };
+    } catch (e) {
+        return {
+            expr,
+            type: t.tsStringKeyword(),
+            exp: emitCall('ExpString', [t.stringLiteral(str)])
+        };
+    }
 };
 
 const compileEscapeToString = (node: g.Escape | g.Special | g.SpecialClass): string => {

packages/pgen/grammar.gg

@@ -1,27 +1,28 @@
 Grammar = rules:Rule*;
-Rule = name:ident formals:formals? "=" body:ruleBody ";";
+Rule = name:ident display:string? formals:formals? "=" body:ruleBody ";";
 formals = "<" @(head:ident tail:("," @ident)*)? ">";
-ruleBody = @Alt;
+ruleBody = Alt;
 Alt = head:Seq tail:("/" @Seq)*;
 Seq = exprs:Sel*;
 Sel = selector:selector? expr:Iter;
-selector = @Name / @Choose;
+selector = Name / Choose;
 Name = name:ident ":";
 Choose = "@";
 Iter = prefix:(@[!&#$])* expr:base suffix:(@[*+?])?;
-base = @Apply / @#Class / @#Terminal / @paren / @Any;
+base = Apply / #Class / Terminal / paren / Any;
 Apply = name:ident params:params?;
-params = "<" @(head:Seq tail:("," @Seq)*)? ">";
-Class = "[" negated:"^"? seqs:classSeq* "]" insensitive:"i"?;
+params = "<" @(head:Alt tail:("," @Alt)*)? ">";
+Class = "[" negated:"^"? seqs:classSeq* "]";
 classSeq = @Group / @classChar;
 Group = from:classChar "-" to:classChar;
 classChar = "\\" @(@SpecialClass / @escape) / @ClassChar;
 SpecialClass = value:[\\\]];
 ClassChar = value:[^\\\]];
-Terminal = "\"" value:char* "\"";
+Terminal = value:string;
+string = #("\"" @char* "\"");
 paren = "(" @Alt ")";
 Any = ".";
-ident = @$#([a-z_]i [a-z0-9_]i*);
+ident = @#$([a-zA-Z_] [a-zA-Z0-9_]*);
 char = "\\" @(@Special / @escape) / @Char;
 Char = value:[^\\"];
 escape = @Named / @unicode / @Ascii;
@@ -31,7 +32,7 @@ unicode = "u" @(@Short / @Long);
 Short = value:$(hexDigit hexDigit hexDigit hexDigit);
 Long = "{" value:$hexDigit+ "}";
 Ascii = "x" value:$(hexDigit hexDigit);
-hexDigit = [0-9a-f]i;
+hexDigit = [0-9a-fA-F];
 space = [ \t\n\r] / Single / Multi;
 Single = "//" value:$[^\n\r]*;
 Multi = "/*" value:$(!"*/" .)* "*/";