#69 Store parameters as object rather than array.

Author: alessiostalla

src/parsing/tylasu-parser.ts

@@ -197,7 +197,10 @@ export abstract class TylasuParser<
                 issues.push(Issue.syntactic(message, IssueSeverity.ERROR, Position.ofParseTree(it),
                     undefined,
                     ERROR_NODE_FOUND,
-                    [it.symbol?.type?.toString() || "", it.symbol?.text || ""]));
+                    {
+                        type: it.symbol?.type?.toString() || "",
+                        text: it.symbol?.text || ""
+                    }));
             });
     }
 

src/transformation/transformation.ts

@@ -266,15 +266,15 @@ export class ASTTransformer {
             if (this.allowGenericNode) {
                 const origin : Origin | undefined = this.asOrigin(source);
                 nodes = [new GenericNode(parent).withOrigin(origin)];
-                const nodeName = getNodeDefinition(source)?.name || source?.constructor.name || "–";
+                const nodeType = getNodeDefinition(source)?.name || source?.constructor.name || "–";
                 this.issues.push(
                     Issue.semantic(
-                        `Source node not mapped: ${nodeName}`,
+                        `Source node not mapped: ${nodeType}`,
                         IssueSeverity.INFO,
                         origin?.position,
                         origin instanceof Node ? origin : undefined,
                         SOURCE_NODE_NOT_MAPPED,
-                        [nodeName]
+                        { nodeType }
                     )
                 );
             } else {

src/validation.ts

@@ -14,25 +14,25 @@ export class Issue {
         public readonly position?: Position,
         public readonly node?: Node,
         public readonly code?: string,
-        public readonly args: string[] = []
+        public readonly args: { [key: string]: string } = {}
         ) {
         if (!position) {
             this.position = node?.position;
         }
     }
 
     static lexical(message: string, severity: IssueSeverity = IssueSeverity.ERROR, position?: Position,
-                   node?: Node, code?: string, args: string[] = []): Issue {
+                   node?: Node, code?: string, args: { [key: string]: string } = {}): Issue {
         return new Issue(IssueType.LEXICAL, message, severity, position, node, code, args);
     }
 
     static syntactic(message: string, severity: IssueSeverity = IssueSeverity.ERROR, position?: Position,
-                     node?: Node, code?: string, args: string[] = []): Issue {
+                     node?: Node, code?: string, args: { [key: string]: string } = {}): Issue {
         return new Issue(IssueType.SYNTACTIC, message, severity, position, node, code, args);
     }
 
     static semantic(message: string, severity: IssueSeverity = IssueSeverity.ERROR, position?: Position,
-                    node?: Node, code?: string, args: string[] = []): Issue {
+                    node?: Node, code?: string, args: { [key: string]: string } = {}): Issue {
         return new Issue(IssueType.SEMANTIC, message, severity, position, node, code, args);
     }
 }

tests/issues.test.ts

@@ -26,7 +26,8 @@ describe('Issues', function() {
             });
             let issue = Issue.syntactic("Unexpected token: foo", IssueSeverity.ERROR, undefined, undefined, SYNTAX_ERROR);
             expect(i18next.t(issue.code!)).to.equal("A syntax error occurred!");
-            issue = Issue.syntactic("Unexpected token: foo", IssueSeverity.ERROR, undefined, undefined, SOURCE_NODE_NOT_MAPPED, ["SomeNode"]);
-            expect(i18next.t(issue.code!, { type: issue.args[0] })).to.equal("Source node not mapped: SomeNode");
+            issue = Issue.semantic("Node not mapped: SomeNode", IssueSeverity.ERROR, undefined, undefined,
+                SOURCE_NODE_NOT_MAPPED,  { nodeType: "SomeNode" });
+            expect(i18next.t(issue.code!, { type: issue.args.nodeType })).to.equal("Source node not mapped: SomeNode");
         });
 });