darijacode 0.2.0

package/LICENSE

@@ -0,0 +1,130 @@
+# DarijaCode Community License (DCL) v1.0
+
+Copyright (c) 2025–present, krnl0xsns1nk and DarijaCode contributors.
+
+This is a custom license. It is not a standard OSI-approved license — read
+it, don't assume it matches something you've seen before.
+
+---
+
+## Plain-language summary (not a substitute for the terms below)
+
+-  Install it, run it, change it, learn from it, do basically whatever you want with it.
+-  Build extra tools around it — an IDE, docs, an editor, error tooling, new language features — as your own separate project.
+-  Fork it, fix it, ship your own build.
+
+-  Don't take this project and present it as something you created. Keep the credit where it belongs.
+-  Don't publish a fork and call it "DarijaCode" as if it's the original, official project.
+
+- 🕊️ If the maintainer goes quiet for a long stretch, the community is free to keep this project alive — fixes, releases, all of it — until the maintainer returns, if ever.
+
+If anything below conflicts with this summary, the terms below control.
+
+---
+
+## 1. Definitions
+
+- **"The Project"** means the DarijaCode source code, documentation, and
+  associated files in this repository.
+- **"You"** means anyone using, copying, modifying, or distributing the
+  Project under this license.
+- **"Derivative Tool"** means a separate piece of software that works with
+  or alongside the Project — an editor, IDE plugin, documentation site,
+  linter, error formatter, package manager frontend, new-feature add-on,
+  and so on — but is not itself a redistribution of the Project as a
+  whole.
+- **"The Maintainer"** means krnl0xsns1nk, the original author of the
+  Project, or anyone the Maintainer formally designates in writing.
+
+## 2. What you're permitted to do
+
+You are granted a free, worldwide, royalty-free license to:
+
+1. **Use** the Project for any purpose, personal or commercial.
+2. **Study and learn from** the source code.
+3. **Modify** the source code, for your own use or to contribute back.
+4. **Copy and redistribute** the Project, or your modified version of it,
+   subject to Section 3 (Attribution) and Section 4 (No Misrepresentation)
+   below.
+5. **Build and distribute Derivative Tools** — an IDE, a docs site, a code
+   editor, error-handling libraries, new language features, package
+   registries, and so on — under any license you choose, including
+   proprietary or commercial ones, as long as the Derivative Tool does not
+   itself claim to *be* DarijaCode (see Section 4).
+
+## 3. Attribution
+
+Any copy or substantial redistribution of the Project, modified or not,
+must:
+
+1. Keep this license file intact.
+2. Retain a visible credit to the original author and a link to the
+   original repository, in the copy's README or an equally prominent
+   location.
+3. Clearly state, if modified, that changes were made.
+
+## 4. No misrepresentation of authorship or origin
+
+This is the core restriction of this license, and the main reason it
+isn't a plain MIT/ISC license:
+
+1. You may **not** present the Project, or a fork of it, as your own
+   original creation.
+2. You may **not** publish a fork, rebrand, or redistribution in a way
+   that implies it is the official or original DarijaCode project, unless
+   you are the Maintainer or have been designated as a steward under
+   Section 5.
+3. Forks are welcome and encouraged, but must be clearly labeled as a
+   fork or derivative (e.g. "MyLang, a DarijaCode fork") — not presented
+   as if it were the primary project or as if you created it from
+   scratch.
+4. Derivative Tools (Section 2.5) are exempt from labeling themselves as
+   a "fork," since they are separate works — but they may not claim to
+   have authored the DarijaCode language or compiler itself.
+
+## 5. Maintainer inactivity and community stewardship
+
+This project is maintained by one person, for fun, with no promises about
+how long that continues. So:
+
+1. **Active** means the Maintainer has made at least one commit to the
+   main repository within the preceding **6 months**.
+2. If the Project becomes **inactive** by that definition, the community
+   is explicitly permitted, without needing to ask, to:
+   - Fork the repository and continue development, bug fixes, and
+     releases under this same license.
+   - Coordinate a community-maintained fork as the de facto continuation
+     of the project, clearly labeled as community-maintained (per
+     Section 4.3) for as long as the Maintainer remains inactive.
+3. If the Maintainer resumes committing to the original repository, the
+   original repository remains the canonical project, and community
+   forks are expected to acknowledge this and may merge their work back
+   if the Maintainer is willing.
+4. This clause does not transfer copyright or ownership — it is a
+   standing permission to fork, maintain, and release, granted in
+   advance, so the community never has to wait for a response that may
+   never come.
+
+## 6. No warranty
+
+The Project is provided "as is," without warranty of any kind, express or
+implied, including but not limited to warranties of merchantability,
+fitness for a particular purpose, and non-infringement. In no event shall
+the Maintainer or contributors be liable for any claim, damages, or other
+liability arising from the Project or its use.
+
+## 7. Termination
+
+Your rights under this license terminate automatically if you violate
+Section 4 (No Misrepresentation) and do not correct the violation within
+30 days of being notified. All other rights survive termination for
+copies already lawfully distributed.
+
+---
+
+*This license was written in plain terms to match how the Maintainer
+actually wants this project used. If you need a legally binding
+interpretation for a specific situation (e.g. enterprise use, a
+large-scale fork, a dispute), consult a lawyer — this document has not
+been reviewed by one.*
+

package/README.md

@@ -0,0 +1,78 @@
+<div align="center">
+
+# 🕊️ DarijaCode
+
+A programming language and compiler written for fun, using Moroccan Darija.
+
+[![Status](https://img.shields.io/badge/status-experimental-orange)](https://github.com/krnl0xsns1nk/DarijaCode)
+[![Language](https://img.shields.io/badge/language-TypeScript-3178c6)](https://www.typescriptlang.org/)
+[![License](https://img.shields.io/badge/license-DCL-blue)](LICENSE)
+[![GitHub stars](https://img.shields.io/github/stars/krnl0xsns1nk/DarijaCode?style=social)](https://github.com/krnl0xsns1nk/DarijaCode)
+
+</div>
+
+---
+
+## Installation
+
+### Quick install
+
+Linux / Termux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/krnl0xsns1nk/DarijaCode/main/scripts/install.sh | sh
+```
+
+---
+
+
+> **DarijaCode is a hobby project built for learning compiler development and experimenting with a programming language based on Moroccan Darija.**
+>
+> It is **not** trying to replace JavaScript, Python, C, or any existing language.
+
+---
+
+## Why?
+
+The goal isn't simply replacing English keywords.
+
+The goal is building a complete programming ecosystem where everything speaks Darija:
+
+- lexer
+- parser
+- semantic checker
+- native compiler
+- CLI
+- runtime
+- package manager *(planned)*
+- standard library *(planned)*
+- compiler errors written in Darija
+
+For example:
+
+```drj
+kteb("Salam");
+```
+and when something goes wrong, the compiler also responds in Darija:
+- take a real example of mine :
+
+<pre style="background:#0d1117; color:#c9d1d9; padding:16px; border-radius:8px; font-family:monospace; overflow-x:auto">
+<span style="color:#7ee787">user@localhost</span> <span style="color:#a5d6ff">~/projects/DarijaCode</span> <span style="color:#ffa657">(master●)</span>
+<span style="color:#7ee787">$</span> <span style="color:#ffa657">bat ex.drj</span>
+
+ <span style="color:#8b949e">│</span> <span style="color:#8b949e">File: ex.drj</span>
+<span style="color:#8b949e">──┼────────────────────────────────────────</span>
+<span style="color:#8b949e">1</span> <span style="color:#8b949e">│</span> <span style="color:#d2a8ff">dir</span> <span style="color:#79c0ff">name</span> <span style="color:#c9d1d9">:</span> <span style="color:#79c0ff">ra9m</span> <span style="color:#c9d1d9">=</span> <span style="color:#a5d6ff">"krnl0xsns"</span><span style="color:#c9d1d9">;</span>
+<span style="color:#8b949e">2</span> <span style="color:#8b949e">│</span> <span style="color:#d2a8ff">kteb</span><span style="color:#c9d1d9">(</span><span style="color:#79c0ff">name</span><span style="color:#c9d1d9">);</span>
+<span style="color:#8b949e">──┴────────────────────────────────────────</span>
+
+<span style="color:#7ee787">user@localhost</span> <span style="color:#a5d6ff">~/projects/DarijaCode</span> <span style="color:#ffa657">(master●)</span>
+<span style="color:#7ee787">$</span> <span style="color:#ffa657">drj run ex.drj</span>
+<span style="color:#f85149; font-weight:bold">DarijaCode error[checker:DCE15]</span> <span style="color:#ffa657">twa93na ra9m, wlkin l9ina nass</span>
+<span style="color:#58a6ff">--> /data/data/com.termux/files/home/projects/DarijaCode/ex.drj:1:1</span>
+<span style="color:#8b949e">1</span> <span style="color:#8b949e">│</span> <span style="color:#d2a8ff">dir</span> <span style="color:#79c0ff">name</span> <span style="color:#c9d1d9">:</span> <span style="color:#79c0ff">ra9m</span> <span style="color:#c9d1d9">=</span> <span style="color:#a5d6ff">"krnl0xsns"</span><span style="color:#c9d1d9">;</span>
+  <span style="color:#8b949e">│</span> <span style="color:#f85149">^</span>
+<span style="color:#a371f7">jrb/chof:</span> <span style="color:#ffa657">ach ban link tstkhdm ra9m fbalst nass</span>
+</pre>
+
+- see docs/error_codes.md for more info about these codes.

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const index_1 = __importDefault(require("./compiler/index"));
+const VERSION = "0.2.0";
+function error(message) {
+    console.error(`✗ ${message}`);
+    process.exit(1);
+}
+function success(message) {
+    console.log(`✓ ${message}`);
+}
+function validateFile(file) {
+    const path = (0, path_1.resolve)(file);
+    if (!(0, fs_1.existsSync)(path)) {
+        error(`milaf mkaynch: ${path}`);
+    }
+    if ((0, path_1.extname)(path) !== ".drj") {
+        error(`twa93t milf b .drj`);
+    }
+    return path;
+}
+function help() {
+    console.log(`
+DarijaCode ${VERSION}
+
+listikhdam:
+  drj run <file>
+  drj build <file>
+  drj check <file>
+
+lawamir:
+  run      Compile and execute
+  build    Compile to binary
+  check    Check syntax and types
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        help();
+        return;
+    }
+    const command = args[0];
+    const v = ["--verion", "version", "-v", "--v", "-version", "lisdar", "--isdar"];
+    if (v.includes(command)) {
+        console.log(VERSION);
+        return;
+    }
+    const file = args[1];
+    if (!file) {
+        error("khask milf dyal .drj");
+    }
+    const filePath = validateFile(file);
+    switch (command) {
+        case "check": {
+            (0, index_1.default)("check", filePath);
+            break;
+        }
+        case "run": {
+            (0, index_1.default)("run", filePath);
+            break;
+        }
+        case "build": {
+            (0, index_1.default)("build", filePath);
+            break;
+        }
+        default:
+            help();
+    }
+}
+main();

package/dist/compiler/ast.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compiler/checker/expressions.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionChecker = void 0;
+const errors_1 = require("../errors");
+const showType_1 = require("../../utils/showType");
+const types_1 = require("./types");
+/**
+ * ExpressionChecker handles type inference for all expression types.
+ * Validates expressions and returns their inferred types.
+ */
+class ExpressionChecker {
+    functions;
+    typeChecker;
+    constructor(functions) {
+        this.functions = functions;
+        this.typeChecker = new types_1.TypeChecker();
+    }
+    /**
+     * Infer the type of an expression.
+     * Performs semantic validation and returns the resulting type.
+     */
+    inferType(expr, scope) {
+        switch (expr.type) {
+            case "NumericLiteral":
+                return { base: "ra9m", d: 0 };
+            case "StringLiteral":
+                return { base: "nass", d: 0 };
+            case "BooleanLiteral":
+                return { base: "tona2i", d: 0 };
+            case "NullLiteral":
+                return { base: "khawi", d: 0 };
+            case "ArrayExpression":
+                return this.checkArrayExpression(expr, scope);
+            case "Identifier":
+                return this.checkIdentifier(expr, scope);
+            case "AssignmentExpression":
+                return this.checkAssignmentExpression(expr, scope);
+            case "BinaryExpression":
+                return this.checkBinaryExpression(expr, scope);
+            case "LogicalExpression":
+                return this.checkLogicalExpression(expr, scope);
+            case "UnaryExpression":
+                return this.checkUnaryExpression(expr, scope);
+            case "UpdateExpression":
+                return this.checkUpdateExpression(expr, scope);
+            case "ConditionalExpression":
+                return this.checkConditionalExpression(expr, scope);
+            case "CallExpression":
+                return this.checkCallExpression(expr, scope);
+            case "MemberExpression":
+                return this.checkMemberExpression(expr, scope);
+            default:
+                throw new errors_1.DarijaError({
+                    code: "DCE-2",
+                    stage: "checker",
+                    message: `'${expr.type}' ba9i mmd3omach`,
+                    location: {
+                        line: expr.pos.line,
+                        column: expr.pos.column,
+                    },
+                });
+        }
+    }
+    checkArrayExpression(expr, scope) {
+        if (expr.elements.length === 0) {
+            return { base: "unknown", d: 1 };
+        }
+        const elementType = this.inferType(expr.elements[0], scope);
+        for (const element of expr.elements) {
+            this.inferType(element, scope);
+        }
+        return {
+            base: elementType.base,
+            d: (elementType.d ?? 0) + 1,
+        };
+    }
+    checkIdentifier(expr, scope) {
+        const info = scope.resolve(expr.name);
+        if (!info) {
+            throw new errors_1.DarijaError({
+                code: "DCE1",
+                stage: "checker",
+                message: `'${expr.name}' mm3rofach`,
+                location: {
+                    line: expr.pos.line,
+                    column: expr.pos.column,
+                },
+            });
+        }
+        return info.type;
+    }
+    checkAssignmentExpression(expr, scope) {
+        const valueType = this.inferType(expr.value, scope);
+        if (expr.target.type === "Identifier") {
+            const info = scope.resolve(expr.target.name);
+            if (!info) {
+                throw new errors_1.DarijaError({
+                    code: "DCE1",
+                    stage: "checker",
+                    message: `'${expr.target.name}' mm3rofch`,
+                    location: {
+                        line: expr.pos.line,
+                        column: expr.pos.column,
+                    },
+                });
+            }
+            if (info.kind === "khli") {
+                throw new errors_1.DarijaError({
+                    code: "DCE16",
+                    stage: "checker",
+                    message: `mat9drh t3ti 9ima l '${expr.target.name}', la79ach how tabit (m3rf b 'khli')`,
+                    location: {
+                        line: expr.pos.line,
+                        column: expr.pos.column,
+                    },
+                });
+            }
+            if (info.type.base !== types_1.UNKNOWN &&
+                !this.typeChecker.compatible(info.type, valueType)) {
+                throw new errors_1.DarijaError({
+                    code: "DCE15",
+                    stage: "checker",
+                    message: `twa93na ${(0, showType_1.showType)(info.type)}, wlkin l9ina ${(0, showType_1.showType)(valueType)}`,
+                    location: {
+                        line: expr.pos.line,
+                        column: expr.pos.column,
+                    },
+                });
+            }
+        }
+        else {
+            this.inferType(expr.target, scope);
+        }
+        return valueType;
+    }
+    checkBinaryExpression(expr, scope) {
+        const leftType = this.inferType(expr.left, scope);
+        const rightType = this.inferType(expr.right, scope);
+        if (["==", "!=", "<", "<=", ">", ">="].includes(expr.operator)) {
+            return { base: "tona2i", d: 0 };
+        }
+        if (expr.operator === "+") {
+            if (this.typeChecker.isType(leftType, "nass") || this.typeChecker.isType(rightType, "nass")) {
+                return { base: "nass", d: 0 };
+            }
+            this.typeChecker.expectType(leftType, "ra9m", expr.pos);
+            this.typeChecker.expectType(rightType, "ra9m", expr.pos);
+            return { base: "ra9m", d: 0 };
+        }
+        // Other arithmetic operators require numbers
+        this.typeChecker.expectType(leftType, "ra9m", expr.pos);
+        this.typeChecker.expectType(rightType, "ra9m", expr.pos);
+        return { base: "ra9m", d: 0 };
+    }
+    checkLogicalExpression(expr, scope) {
+        this.inferType(expr.left, scope);
+        this.inferType(expr.right, scope);
+        return { base: "tona2i", d: 0 };
+    }
+    checkUnaryExpression(expr, scope) {
+        const argType = this.inferType(expr.argument, scope);
+        if (expr.operator === "!") {
+            return { base: "tona2i", d: 0 };
+        }
+        this.typeChecker.expectType(argType, "ra9m", expr.pos);
+        return { base: "ra9m", d: 0 };
+    }
+    checkUpdateExpression(expr, scope) {
+        const argType = this.inferType(expr.argument, scope);
+        this.typeChecker.expectType(argType, "ra9m", expr.pos);
+        return { base: "ra9m", d: 0 };
+    }
+    checkConditionalExpression(expr, scope) {
+        this.inferType(expr.condition, scope);
+        const consequentType = this.inferType(expr.consequent, scope);
+        const alternateType = this.inferType(expr.alternate, scope);
+        return consequentType === alternateType
+            ? consequentType
+            : { base: types_1.UNKNOWN, d: 0 };
+    }
+    checkCallExpression(expr, scope) {
+        if (expr.callee.type !== "Identifier") {
+            throw new errors_1.DarijaError({
+                code: "DCE-2",
+                stage: "checker",
+                message: "ghir dawal direct lli md3omim",
+                location: {
+                    line: expr.pos.line,
+                    column: expr.pos.column,
+                },
+            });
+        }
+        const fn = this.functions.get(expr.callee.name);
+        if (!fn) {
+            throw new errors_1.DarijaError({
+                code: "DCE1",
+                stage: "checker",
+                message: `dala '${expr.callee.name}' mm3rofach`,
+                location: {
+                    line: expr.pos.line,
+                    column: expr.pos.column,
+                },
+                hint: `dir ta3rif l dala ${expr.callee.name} bhal haka : dalla ${expr.callee.name}(){ chi logic }}`,
+            });
+        }
+        const required = fn.params.filter((p) => !p.defaultValue).length;
+        if (expr.args.length < required ||
+            expr.args.length > fn.params.length) {
+            throw new errors_1.DarijaError({
+                code: "DCE17",
+                stage: "checker",
+                message: `'${expr.callee.name}' twa93 ${required === fn.params.length
+                    ? required
+                    : `${required}-${fn.params.length}`} dyal lhojaj, wlkin l9a ${expr.args.length}`,
+                location: {
+                    line: expr.pos.line,
+                    column: expr.pos.column,
+                },
+            });
+        }
+        expr.args.forEach((arg, i) => {
+            const argType = this.inferType(arg, scope);
+            const param = fn.params[i];
+            if (param.typeAnnotation &&
+                !this.typeChecker.compatible(param.typeAnnotation, argType)) {
+                throw new errors_1.DarijaError({
+                    code: "DCE15",
+                    stage: "checker",
+                    message: `twa93na ${(0, showType_1.showType)(param.typeAnnotation)}, wlkin l9ina ${(0, showType_1.showType)(argType)}`,
+                    location: {
+                        line: expr.pos.line,
+                        column: expr.pos.column,
+                    },
+                });
+            }
+        });
+        return fn.returnType ?? { base: types_1.UNKNOWN, d: 0 };
+    }
+    checkMemberExpression(expr, scope) {
+        const objectType = this.inferType(expr.object, scope);
+        if (expr.computed)
+            this.inferType(expr.property, scope);
+        return objectType.d
+            ? { base: objectType.base, d: objectType.d - 1 }
+            : { base: types_1.UNKNOWN, d: 0 };
+    }
+}
+exports.ExpressionChecker = ExpressionChecker;

package/dist/compiler/checker/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checker = void 0;
+const errors_1 = require("../errors");
+const scope_1 = require("./scope");
+const statements_1 = require("./statements");
+class Checker {
+    globalScope = new scope_1.Scope();
+    functions = new scope_1.FunctionRegistry();
+    statementChecker;
+    constructor() {
+        this.statementChecker = new statements_1.StatementChecker(this.functions, this.globalScope);
+    }
+    check(program) {
+        // Pass 1: Hoist function signatures
+        for (const stmt of program.body) {
+            if (stmt.type === "FunctionDeclaration") {
+                this.registerFunctionSignature(stmt);
+            }
+        }
+        // Pass 2: Validate all statements
+        for (const stmt of program.body) {
+            this.statementChecker.checkStatement(stmt, this.globalScope);
+        }
+    }
+    registerFunctionSignature(fn) {
+        if (this.functions.has(fn.name)) {
+            throw new errors_1.DarijaError({
+                code: "DCE13",
+                stage: "checker",
+                message: `dala '${fn.name}' dija m3rfa`,
+                location: {
+                    line: fn.pos.line,
+                    column: fn.pos.column,
+                },
+                hint: `stkhdm dalla dyal ${fn.name}() awla dir dalla jdida`,
+            });
+        }
+        this.functions.register(fn.name, {
+            params: fn.params,
+            returnType: fn.returnType ?? { base: "walo", d: 0 },
+        }, fn.pos.line, fn.pos.column);
+    }
+}
+exports.Checker = Checker;

package/dist/compiler/checker/scope.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionRegistry = exports.Scope = void 0;
+const errors_1 = require("../errors");
+//welcome to the scope
+class Scope {
+    parent;
+    vars = new Map();
+    constructor(parent = null) {
+        this.parent = parent;
+    }
+    declare(name, info, line, column) {
+        if (this.vars.has(name)) {
+            throw new errors_1.DarijaError({
+                code: "DCE13",
+                stage: "checker",
+                message: `'${name}' dija m3rfa`,
+                location: { line, column },
+                hint: `${name} = 9ima fblast (dir/khli ${name} = 9ima)`,
+            });
+        }
+        this.vars.set(name, info);
+    }
+    resolve(name) {
+        return this.vars.get(name) ?? this.parent?.resolve(name);
+    }
+    child() {
+        return new Scope(this);
+    }
+}
+exports.Scope = Scope;
+/**
+ * Global function registry.
+ * Tracks all function signatures for validation during calls and recursion.
+ */
+class FunctionRegistry {
+    functions = new Map();
+    register(name, info, line, column) {
+        if (this.functions.has(name)) {
+            throw new errors_1.DarijaError({
+                code: "DCE13",
+                stage: "checker",
+                message: `dala '${name}' dija m3rfa`,
+                location: { line, column },
+                hint: `stkhdm dalla dyal ${name}() awla dir dalla jdida`,
+            });
+        }
+        this.functions.set(name, info);
+    }
+    get(name) {
+        return this.functions.get(name);
+    }
+    has(name) {
+        return this.functions.has(name);
+    }
+}
+exports.FunctionRegistry = FunctionRegistry;