brett-compiler 1.0.2

package/dist/SemanticAnalyserVisitor.js

@@ -0,0 +1,191 @@
+const BrettVisitor = require('./generated/BrettVisitor').default;
+const { SymbolKind } = require('./model.js');
+const { SymbolTable } = require('./SymbolTable.js');
+
+const parserModule = require('./generated/BrettParser');
+const BrettParser = parserModule.BrettParser || parserModule.default || parserModule;
+
+class SemanticAnalyzerVisitor extends BrettVisitor {
+    constructor() {
+        super();
+        this.errors = [];
+        this.currentScope = new SymbolTable();
+        this.allScopes = [];
+    }
+
+    addError(message, token, severity = 'error') {
+        const line = token ? token.line : 0;
+        const column = token ? token.column + 1 : 0;
+        const length = token ? token.text.length : 1;
+
+        this.errors.push({
+            message,
+            line,
+            column,
+            type: severity === 'error' ? 'Semantic Error' : 'Warning',
+            length
+        });
+    }
+
+    checkAssignment(declaredType, actualType, token) {
+        // If either side is 'any', we assume it's valid (or already an error)
+        if (declaredType === 'any' || actualType === 'any') {
+            return true;
+        }
+
+        // Strict string comparison
+        if (String(declaredType) !== String(actualType)) {
+            this.addError(
+                `Type '${actualType}' kan niet worden toegewezen aan type '${declaredType}'`,
+                token
+            );
+            return false;
+        }
+        return true;
+    }
+
+    getSymbols() {
+        const allSymbols = new Map();
+        this.allScopes.forEach(scope => {
+            if (scope.symbols) {
+                for (const [name, symbol] of scope.symbols.entries()) {
+                    if (!allSymbols.has(name)) allSymbols.set(name, symbol);
+                }
+            }
+        });
+        ['string', 'number', 'bool', 'any'].forEach(t =>
+            allSymbols.set(t, { name: t, kind: 'Type', type: 'type' })
+        );
+        return Array.from(allSymbols.values());
+    }
+
+    visitProgram(ctx) { this.visitChildren(ctx); }
+
+    visitBlock(ctx) {
+        this.currentScope = new SymbolTable(this.currentScope);
+        this.visitChildren(ctx);
+        this.allScopes.push(this.currentScope);
+        this.currentScope = this.currentScope.parent;
+    }
+
+    visitFunctionDeclaration(ctx) {
+        const identifierNode = ctx.IDENTIFIER();
+        if (!identifierNode) return;
+
+        const name = identifierNode.getText();
+        const returnType = ctx.type()?.getText() ?? 'any';
+
+        if (!this.currentScope.define({ name, kind: SymbolKind.Function, type: returnType })) {
+            this.addError(`Functie '${name}' is al gedefinieerd.`, identifierNode.getSymbol());
+        }
+
+        this.currentScope = new SymbolTable(this.currentScope);
+        if (ctx.parameterList()) this.visit(ctx.parameterList());
+        if (ctx.block()) this.visit(ctx.block());
+        this.currentScope = this.currentScope.parent;
+    }
+
+    visitParameter(ctx) {
+        const identifierNode = ctx.IDENTIFIER();
+        if (!identifierNode) return;
+        const name = identifierNode.getText();
+        const type = ctx.type()?.getText() ?? 'any';
+        this.currentScope.define({ name, kind: SymbolKind.Parameter, type });
+    }
+
+    visitVariableDeclaration(ctx) {
+        const identifierNode = ctx.IDENTIFIER();
+        if (!identifierNode) return;
+
+        const name = identifierNode.getText();
+        const declaredType = ctx.type()?.getText() ?? 'any';
+        const identifierToken = identifierNode.getSymbol();
+
+        if (!/^[a-z]/.test(name)) {
+            this.addError(`Variabele '${name}' moet met kleine letter beginnen.`, identifierToken, 'warning');
+        }
+
+        if (!this.currentScope.define({ name, kind: SymbolKind.Variable, type: declaredType })) {
+            this.addError(`Variabele '${name}' is al gedefinieerd.`, identifierToken);
+        }
+
+        if (ctx.expression()) {
+            const exprType = this.visit(ctx.expression());
+            this.checkAssignment(declaredType, exprType, ctx.expression().start);
+        }
+    }
+
+    // ================= EXPRESSION VISITORS =================
+
+    visitAssignmentExpression(ctx) {
+        const name = ctx.IDENTIFIER().getText();
+        const symbol = this.currentScope.resolve(name);
+        const token = ctx.IDENTIFIER().getSymbol();
+
+        if (!symbol) {
+            this.addError(`Variabele '${name}' is niet gevonden in deze scope.`, token);
+        } else if (symbol.kind !== SymbolKind.Variable && symbol.kind !== SymbolKind.Parameter) {
+            this.addError(`'${name}' is geen variabele.`, token);
+        }
+
+        const valType = this.visit(ctx.expression());
+
+        if (symbol) {
+            this.checkAssignment(symbol.type, valType, ctx.expression().start);
+        }
+        return valType;
+    }
+
+    visitBinaryExpression(ctx) {
+        const leftType = this.visit(ctx.expression(0));
+        const rightType = this.visit(ctx.expression(1));
+        const operator = ctx.op.text;
+
+        if (leftType === 'number' && rightType === 'number') {
+            if (['<', '>', '<=', '>=', '==', '!='].includes(operator)) return 'bool';
+            return 'number';
+        }
+
+        if (operator === '+' && (leftType === 'string' || rightType === 'string')) {
+            return 'string';
+        }
+        return 'any';
+    }
+
+    visitIdentifierExpression(ctx) {
+        const name = ctx.IDENTIFIER().getText();
+        const symbol = this.currentScope.resolve(name);
+
+        if (!symbol) {
+            this.addError(`Variabele '${name}' is niet gevonden in deze scope.`, ctx.IDENTIFIER().getSymbol());
+            // Important: Return 'any' so checkAssignment logic above ignores it
+            return 'any';
+        }
+        return symbol.type;
+    }
+
+    visitFunctionCallExpression(ctx) {
+        const name = ctx.IDENTIFIER().getText();
+        const symbol = this.currentScope.resolve(name);
+
+        if (!symbol || symbol.kind !== SymbolKind.Function) {
+            this.addError(`Functie '${name}' is niet gedefinieerd.`, ctx.IDENTIFIER().getSymbol());
+            return 'any';
+        }
+        if (ctx.argList()) this.visit(ctx.argList());
+        return symbol.type;
+    }
+
+    visitLiteralExpression(ctx) {
+        if (ctx.NUMBER()) return 'number';
+        if (ctx.STRING()) return 'string';
+        if (ctx.getText() === 'true' || ctx.getText() === 'false') return 'bool';
+        return 'any';
+    }
+
+    visitParenthesizedExpression(ctx) {
+        return this.visit(ctx.expression());
+    }
+}
+
+module.exports = { SemanticAnalyzerVisitor };

package/dist/SymbolTable.js

@@ -0,0 +1,24 @@
+const { SymbolKind } = require('./model.js');
+
+class SymbolTable {
+    constructor(parent = null) {
+        this.symbols = new Map();
+        this.parent = parent;
+    }
+
+    define(symbol) {
+        if (this.symbols.has(symbol.name)) return false;
+        this.symbols.set(symbol.name, symbol);
+        return true;
+    }
+
+    resolve(name) {
+        const s = this.symbols.get(name);
+        if (s) return s;
+        // Cruciaal: De recursieve lookup in ouderlijke scopes
+        if (this.parent) return this.parent.resolve(name);
+        return null; // Triggert Fout 8 en 9 in de Visitor
+    }
+}
+
+module.exports = { SymbolTable };

package/dist/SyntaxErrorListener.js

@@ -0,0 +1,24 @@
+class SyntaxErrorListener {
+    constructor(errorsList) {
+        this.errors = errorsList;
+    }
+
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        const length = offendingSymbol ? offendingSymbol.text.length : 1;
+
+        this.errors.push({
+            type: 'Syntax Error',
+            message: msg,
+            line: line,
+            column: column + 1,  // 1-based for the user
+            length: length       // NEW: Store the token length
+        });
+    }
+
+    // Deze lege methodes zijn nodig om als listener te werken
+    reportAmbiguity() {}
+    reportAttemptingFullContext() {}
+    reportContextSensitivity() {}
+}
+
+module.exports = { SyntaxErrorListener };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+
+interface BrettSymbol {
+    name: string;
+    kind: 'Variable' | 'Function' | 'Type' | 'Parameter';
+    type: string;
+}
+
+declare function compile(input: string): {
+    type: string;
+    message: string;
+    line: number;
+    column: number;
+    length: number;
+}[];
+
+declare function analyzeAndGetSymbols(input: string): BrettSymbol[];
+
+export { compile, analyzeAndGetSymbols, BrettSymbol };

package/dist/index.js

@@ -0,0 +1,56 @@
+const antlr4 = require('antlr4');
+
+const lexerModule = require('./generated/BrettLexer');
+const parserModule = require('./generated/BrettParser');
+
+const BrettLexer = lexerModule.BrettLexer || lexerModule.default || lexerModule;
+const BrettParser = parserModule.BrettParser || parserModule.default || parserModule;
+
+const { SemanticAnalyzerVisitor } = require('./SemanticAnalyserVisitor');
+const { SyntaxErrorListener } = require('./SyntaxErrorListener');
+
+function compile(input) {
+    const chars = new antlr4.InputStream(input);
+    const lexer = new BrettLexer(chars);
+    const tokens = new antlr4.CommonTokenStream(lexer);
+    const parser = new BrettParser(tokens);
+
+    const errors = [];
+    parser.removeErrorListeners();
+    parser.addErrorListener(new SyntaxErrorListener(errors));
+
+    const tree = parser.program();
+
+    const visitor = new SemanticAnalyzerVisitor();
+
+    try {
+        visitor.visit(tree);
+    } catch (e) {
+    }
+
+    const allErrors = errors.concat(visitor.errors);
+
+    return allErrors;
+}
+
+function analyzeAndGetSymbols(input) {
+    const chars = new antlr4.InputStream(input);
+    const lexer = new BrettLexer(chars);
+    const tokens = new antlr4.CommonTokenStream(lexer);
+    const parser = new BrettParser(tokens);
+
+    parser.removeErrorListeners();
+
+    const tree = parser.program();
+    const visitor = new SemanticAnalyzerVisitor();
+
+    try {
+        visitor.visit(tree);
+    } catch (e) {
+        console.error("Symbol analysis failed due to syntax error");
+    }
+
+    return visitor.getSymbols();
+}
+
+module.exports = { compile, analyzeAndGetSymbols };

package/dist/model.js

@@ -0,0 +1,7 @@
+const SymbolKind = Object.freeze({
+    Variable: 5,
+    Parameter: 6,
+    Function: 3
+});
+
+module.exports = { SymbolKind };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "brett-compiler",
+  "version": "1.0.2",
+  "description": "Een compiler voor de .Brett taal",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "antlr4": "^4.13.1"
+  },
+  "scripts": {
+    "antlr": "powershell -ExecutionPolicy Bypass -File generate-compiler.ps1",
+    "antlrci": "node generate-compiler.js",
+    "postinstall": "node generate-compiler.js",
+    "start": "node dist/index.js",
+    "test": "vitest",
+    "build": "npm run antlrci && node build.js",
+    "prepublishOnly": "npm run build",
+    "release": "npm run build && standard-version && npm publish --access public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "standard-version": "^9.5.0",
+    "vitest": "^4.0.10"
+  }
+}