@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

package/tests/analyser/semantic-error-scenarios.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { Specification } from "../../src/ast/node/specification.ts";
-import { createStrictSdlAnalyser } from "../../src/analyser/create-sdl-analyser.ts";
-import { createStrictSdlParser } from "../../src/lezer/create-sdl-parser.ts";
-import { SdlStringInput } from "../../src/lezer/sdl-string-input.ts";
-import { buildAst } from "../../src/ast/build-ast.ts";
-
-const sdlParser = createStrictSdlParser();
-const sdlAnalyser = createStrictSdlAnalyser();
-
-describe("Semantic Error Scenario Tests", () => {
-  test("Empty specification ok", () => {
-    const specification = new Specification([]);
-
-    sdlAnalyser.analyse(specification);
-  });
-
-  test("Duplicate global symbol", () => {
-    const sdlStringInput = new SdlStringInput(
-      "computed int a = 1; computed int a = 2;",
-    );
-    const parseTree = sdlParser.parse(sdlStringInput);
-    const specification = buildAst(parseTree, sdlStringInput);
-
-    expect(() => sdlAnalyser.analyse(specification as Specification)).toThrow(
-      "SEMANTIC ERROR: Variable: a is already declared in scope: GLOBAL => { row: 1, column: 34, position: 33 }",
-    );
-  });
-
-  test("Undefined symbol", () => {
-    const sdlStringInput = new SdlStringInput("class A { B b;}");
-    const parseTree = sdlParser.parse(sdlStringInput);
-    const specification = buildAst(parseTree, sdlStringInput);
-
-    expect(() => sdlAnalyser.analyse(specification as Specification)).toThrow(
-      "SEMANTIC ERROR: Class: B is not declared => { row: 1, column: 11, position: 10 }",
-    );
-  });
-});

package/tests/analyser/symbol-table.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  AddSymbolResult,
-  NumericType,
-  ScopeKind,
-  type Symbol,
-  SymbolKind,
-  SymbolTable,
-} from "../../src/analyser/symbol-table.ts";
-import { TokenKind } from "../../src/ast/node/enum/token-kind.ts";
-import { Token } from "../../src/ast/node/token.ts";
-import { Identifier } from "../../src/ast/node/identifier.ts";
-
-describe("Symbol Table Tests", () => {
-  const node = new Identifier(
-    "foo",
-    new Token(TokenKind.IDENTIFIER, "foo", { row: 1, column: 1, position: 0 }),
-  );
-
-  test("Test symbol table creation", () => {
-    const table = new SymbolTable();
-
-    expect(table.getCurrentScope().kind).toBe(ScopeKind.GLOBAL);
-  });
-
-  test("Define and lookup symbol in global scope", () => {
-    const table = new SymbolTable();
-    const symbol: Symbol = {
-      node,
-      name: "MyVariable",
-      kind: SymbolKind.VARIABLE,
-      attributes: {
-        isComputed: true,
-        isConst: true,
-      },
-      location: { row: 1, column: 1, position: 0 },
-    };
-
-    expect(table.addSymbol(symbol)).toBe(AddSymbolResult.SUCCESS);
-    expect(table.lookupVariable("MyVariable")).toBe(symbol);
-  });
-
-  test("Prevent duplicate symbol definition", () => {
-    const table = new SymbolTable();
-    const symbol1: Symbol = {
-      node,
-      name: "MyVariable",
-      kind: SymbolKind.VARIABLE,
-      attributes: {
-        isComputed: true,
-        isConst: true,
-      },
-      location: { row: 1, column: 1, position: 0 },
-    };
-    const symbol2: Symbol = {
-      node,
-      name: "MyVariable",
-      kind: SymbolKind.VARIABLE,
-      attributes: {
-        isComputed: true,
-        isConst: true,
-      },
-      location: { row: 1, column: 1, position: 0 },
-    };
-
-    expect(table.addSymbol(symbol1)).toBe(AddSymbolResult.SUCCESS);
-    expect(table.addSymbol(symbol2)).toBe(AddSymbolResult.DUPLICATE);
-    expect(table.lookupVariable("MyVariable")).toBe(symbol1);
-  });
-
-  test("Prevent conflicting member definition", () => {
-    const table = new SymbolTable();
-
-    const symbol1: Symbol = {
-      node,
-      name: "MyVariable",
-      kind: SymbolKind.VARIABLE,
-      attributes: {
-        numericType: NumericType.INTEGER,
-        isConst: true,
-      },
-      location: { row: 1, column: 1, position: 0 },
-    };
-    const symbol2: Symbol = {
-      node,
-      name: "MyVariable",
-      kind: SymbolKind.VARIABLE,
-      attributes: {
-        numericType: NumericType.FLOATING_POINT,
-        isConst: true,
-      },
-      location: { row: 1, column: 1, position: 0 },
-    };
-
-    table.enterClassScope("A");
-    table.enterBlockScope("COMPOUND");
-    expect(table.addSymbol(symbol1)).toBe(AddSymbolResult.SUCCESS);
-    table.exitScope();
-    table.enterBlockScope("COMPOUND");
-    expect(table.addSymbol(symbol2)).toBe(AddSymbolResult.MEMBER_CONFLICT);
-    table.exitScope();
-  });
-
-  test("Enter and exit scope", () => {
-    const table = new SymbolTable();
-
-    table.enterBlockScope("inner");
-
-    expect(table.getCurrentScope().kind).toBe(ScopeKind.BLOCK);
-    expect(table.getCurrentScope().name).toBe("inner");
-
-    table.exitScope();
-
-    expect(table.getCurrentScope().kind).toBe(ScopeKind.GLOBAL);
-  });
-
-  test("Lookup traverses parent scopes", () => {
-    const table = new SymbolTable();
-    const globalSymbol: Symbol = {
-      node,
-      name: "globalVar",
-      kind: SymbolKind.VARIABLE,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    };
-
-    table.addSymbol(globalSymbol);
-
-    table.enterBlockScope("inner");
-
-    const innerSymbol: Symbol = {
-      node,
-      name: "innerVar",
-      kind: SymbolKind.VARIABLE,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    };
-
-    table.addSymbol(innerSymbol);
-
-    expect(table.lookupVariable("globalVar")).toBe(globalSymbol);
-    expect(table.lookupVariable("innerVar")).toBe(innerSymbol);
-  });
-
-  test("lookupClass returns only CLASS symbols", () => {
-    const table = new SymbolTable();
-
-    table.addSymbol({
-      node,
-      name: "MyClass",
-      kind: SymbolKind.CLASS,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    });
-    table.addSymbol({
-      node,
-      name: "MyMap",
-      kind: SymbolKind.MAP,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    });
-
-    expect(table.lookupClass("MyClass")).toBeDefined();
-    expect(table.lookupClass("MyMap")).toBeUndefined();
-  });
-
-  test("lookupMap returns only MAP symbols", () => {
-    const table = new SymbolTable();
-
-    table.addSymbol({
-      node,
-      name: "MyClass",
-      kind: SymbolKind.CLASS,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    });
-    table.addSymbol({
-      node,
-      name: "MyMap",
-      kind: SymbolKind.MAP,
-      attributes: {},
-      location: { row: 1, column: 1, position: 0 },
-    });
-
-    expect(table.lookupMap("MyMap")).toBeDefined();
-    expect(table.lookupMap("MyClass")).toBeUndefined();
-  });
-});

package/tests/analyser/test-cases/array_definition.txt

@@ -1,50 +0,0 @@
-# Simple
-
-class A {int(3) a[3];}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER []
-    a VARIABLE INTEGER []
-
-
-# Reserved multiple dimensions with mixed explicit and partial dimensions
-
-class MyClass{}
-class A {reserved MyClass a[3][[2]];}
-
-==>
-
-[GLOBAL]:
-  MyClass CLASS
-  A CLASS
-  [CLASS] MyClass:
-  [CLASS] A:
-    members:
-      a VARIABLE (class: MyClass) []
-    a VARIABLE (class: MyClass) []
-
-
-# Implicit dimension
-
-class MyClass{}
-class A {MyClass a[1..3];}
-
-==>
-
-[GLOBAL]:
-  MyClass CLASS
-  A CLASS
-  [CLASS] MyClass:
-  [CLASS] A:
-    members:
-      a VARIABLE (class: MyClass) []
-    a VARIABLE (class: MyClass) []
-
-errors:
-
-SEMANTIC ERROR: Implicit arrays can only contain classes which have a classId defined.

package/tests/analyser/test-cases/class_declaration.txt

@@ -1,112 +0,0 @@
-# Simple class declaration
-
-class A{}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-
-
-# Single parameter with single id
-
-class A(int a) {}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER
-    a VARIABLE INTEGER
-
-errors:
-
-SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.
-
-# All features
-
-class C{}
-aligned(8) expandable(20) abstract class A (int a, B b) extends C(1, d) : bit(3) id=1..2,5 {}
-
-==>
-
-[GLOBAL]:
-  C CLASS
-  A CLASS
-  [CLASS] C:
-  [CLASS] A:
-    members:
-      sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-      a VARIABLE INTEGER
-      b VARIABLE (class: B)
-    sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-    a VARIABLE INTEGER
-    b VARIABLE (class: B)
-
-errors:
-
-SEMANTIC ERROR: Identifier: d is not declared
-SEMANTIC ERROR: Because the class is expandable, it has an encoded sizeOfInstance value therefore it cannot be abstract.
-SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.
-SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.
-SEMANTIC ERROR: The alignment of a class which extends another must not differ from the alignment of the base class.
-
-# maxClassSize must be positive
-
-expandable(0) class A {}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-    sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-
-errors:
-
-SEMANTIC ERROR: maxClassSize must be a positive integer
-
-
-# Expandable class cannot be abstract
-
-expandable(20) abstract class A {}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-    sizeOfInstance VARIABLE INTEGER COMPUTED CONST
-
-errors:
-
-SEMANTIC ERROR: Because the class is expandable, it has an encoded sizeOfInstance value therefore it cannot be abstract.
-
-
-# Unreferenced parameter
-
-class A(int a, int b) {int(8) c = a;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER
-      b VARIABLE INTEGER
-      c VARIABLE INTEGER
-    a VARIABLE INTEGER
-    b VARIABLE INTEGER
-    c VARIABLE INTEGER
-
-errors:
-
-SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.

package/tests/analyser/test-cases/class_definition.txt

@@ -1,60 +0,0 @@
-# Simple
-
-class ClassA {}
-class A {ClassA a;}
-
-==>
-
-[GLOBAL]:
-  ClassA CLASS
-  A CLASS
-  [CLASS] ClassA:
-  [CLASS] A:
-    members:
-      a VARIABLE (class: ClassA)
-    a VARIABLE (class: ClassA)
-
-
-# Legacy and one parameter value
-
-class ClassB(int a) {}
-class A {legacy ClassB b(3);}
-
-==>
-
-[GLOBAL]:
-  ClassB CLASS
-  A CLASS
-  [CLASS] ClassB:
-    members:
-      a VARIABLE INTEGER
-    a VARIABLE INTEGER
-  [CLASS] A:
-    members:
-      b VARIABLE (class: ClassB)
-    b VARIABLE (class: ClassB)
-
-errors:
-
-SEMANTIC ERROR: A parameter in a parameter list must be referenced within the class declaration.
-
-# Multiple parameter values
-
-class ClassC {}
-class A {ClassC c(i, 3);}
-
-==>
-
-[GLOBAL]:
-  ClassC CLASS
-  A CLASS
-  [CLASS] ClassC:
-  [CLASS] A:
-    members:
-      c VARIABLE (class: ClassC)
-    c VARIABLE (class: ClassC)
-
-errors:
-
-SEMANTIC ERROR: Identifier: i is not declared
-SEMANTIC ERROR: Class 'ClassC' does not expect parameters, but 2 provided

package/tests/analyser/test-cases/compound_statement.txt

@@ -1,63 +0,0 @@
-# Simple
-
-class A {{utf8string foo;utf8string bar;}}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      foo VARIABLE UCS (branch: COMPOUND)
-      bar VARIABLE UCS (branch: COMPOUND)
-    [BLOCK] COMPOUND:
-      foo VARIABLE UCS
-      bar VARIABLE UCS
-
-
-# Nested compound statements
-
-class A {{utf8string foo;{ utf8string bar1;utf8string bar2;}}}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      foo VARIABLE UCS (branch: COMPOUND)
-      bar1 VARIABLE UCS (branch: COMPOUND/COMPOUND)
-      bar2 VARIABLE UCS (branch: COMPOUND/COMPOUND)
-    [BLOCK] COMPOUND:
-      foo VARIABLE UCS
-      [BLOCK] COMPOUND:
-        bar1 VARIABLE UCS
-        bar2 VARIABLE UCS
-
-
-# Multiple nested compound statements
-
-class A {{utf8string foo;{ utf8string bar1;utf8string bar2;}}{utf8string fooi;{ utf8string bar1i;utf8string bar2i;}}}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      foo VARIABLE UCS (branch: COMPOUND)
-      bar1 VARIABLE UCS (branch: COMPOUND/COMPOUND)
-      bar2 VARIABLE UCS (branch: COMPOUND/COMPOUND)
-      fooi VARIABLE UCS (branch: COMPOUND#1)
-      bar1i VARIABLE UCS (branch: COMPOUND#1/COMPOUND)
-      bar2i VARIABLE UCS (branch: COMPOUND#1/COMPOUND)
-    [BLOCK] COMPOUND:
-      foo VARIABLE UCS
-      [BLOCK] COMPOUND:
-        bar1 VARIABLE UCS
-        bar2 VARIABLE UCS
-    [BLOCK] COMPOUND#1:
-      fooi VARIABLE UCS
-      [BLOCK] COMPOUND:
-        bar1i VARIABLE UCS
-        bar2i VARIABLE UCS

package/tests/analyser/test-cases/computed_array_definition.txt

@@ -1,12 +0,0 @@
-# Simple
-
-class A {computed int a[3];}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER COMPUTED []
-    a VARIABLE INTEGER COMPUTED []

package/tests/analyser/test-cases/computed_elementary_type_definition.txt

@@ -1,39 +0,0 @@
-# Simple
-
-class A {computed int a;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER COMPUTED
-    a VARIABLE INTEGER COMPUTED
-
-
-# Const and value
-
-class A {computed const int a=3;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER COMPUTED CONST
-    a VARIABLE INTEGER COMPUTED CONST
-
-# Const computed value must be defined
-
-computed const int a;
-
-==>
-
-[GLOBAL]:
-  a VARIABLE INTEGER COMPUTED CONST
-
-errors:
-
-SEMANTIC ERROR: a: const computed elementary type definition must have a value specified

package/tests/analyser/test-cases/do_statement.txt

@@ -1,16 +0,0 @@
-# Simple
-
-class A {do {i++;} while (i<3);}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    [BLOCK] DO:
-      [BLOCK] COMPOUND:
-
-errors:
-
-SEMANTIC ERROR: Identifier: i is not declared
-SEMANTIC ERROR: Identifier: i is not declared

package/tests/analyser/test-cases/elementary_type_definition.txt

@@ -1,58 +0,0 @@
-# Simple
-
-class A{int(3) a;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER
-    a VARIABLE INTEGER
-
-
-# Legacy, const, aligned, lookahead value range
-
-class A{legacy const aligned(8) unsigned int(7)* a=3..i;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER CONST
-    a VARIABLE INTEGER CONST
-
-errors:
-
-SEMANTIC ERROR: Identifier: i is not declared
-
-
-# Default aligned
-
-class A {aligned int(2) a;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER
-    a VARIABLE INTEGER
-
-
-# Explicit aligned bit count
-
-class A {aligned(16) int(2) a;}
-
-==>
-
-[GLOBAL]:
-  A CLASS
-  [CLASS] A:
-    members:
-      a VARIABLE INTEGER
-    a VARIABLE INTEGER