kopscript 0.1.0

package/dist/tokens.js

@@ -0,0 +1,81 @@
+export var TokenKind;
+(function (TokenKind) {
+    // Literals
+    TokenKind["Number"] = "Number";
+    TokenKind["String"] = "String";
+    TokenKind["InterpolatedString"] = "InterpolatedString";
+    TokenKind["RegexLiteral"] = "RegexLiteral";
+    TokenKind["Identifier"] = "Identifier";
+    TokenKind["True"] = "True";
+    TokenKind["False"] = "False";
+    // Keywords
+    TokenKind["Using"] = "Using";
+    TokenKind["Extern"] = "Extern";
+    TokenKind["From"] = "From";
+    TokenKind["As"] = "As";
+    TokenKind["Const"] = "Const";
+    TokenKind["Class"] = "Class";
+    TokenKind["Interface"] = "Interface";
+    TokenKind["Enum"] = "Enum";
+    TokenKind["Constructor"] = "Constructor";
+    TokenKind["Public"] = "Public";
+    TokenKind["Private"] = "Private";
+    TokenKind["Protected"] = "Protected";
+    TokenKind["Static"] = "Static";
+    TokenKind["Virtual"] = "Virtual";
+    TokenKind["Override"] = "Override";
+    TokenKind["Get"] = "Get";
+    TokenKind["Set"] = "Set";
+    TokenKind["Return"] = "Return";
+    TokenKind["If"] = "If";
+    TokenKind["Else"] = "Else";
+    TokenKind["While"] = "While";
+    TokenKind["For"] = "For";
+    TokenKind["Foreach"] = "Foreach";
+    TokenKind["In"] = "In";
+    TokenKind["Break"] = "Break";
+    TokenKind["Continue"] = "Continue";
+    TokenKind["Match"] = "Match";
+    TokenKind["This"] = "This";
+    TokenKind["Base"] = "Base";
+    TokenKind["New"] = "New";
+    TokenKind["Task"] = "Task";
+    TokenKind["State"] = "State";
+    TokenKind["Async"] = "Async";
+    TokenKind["Await"] = "Await";
+    TokenKind["Try"] = "Try";
+    TokenKind["Catch"] = "Catch";
+    TokenKind["Finally"] = "Finally";
+    TokenKind["Throw"] = "Throw";
+    TokenKind["Void"] = "Void";
+    // Punctuation
+    TokenKind["LParen"] = "LParen";
+    TokenKind["RParen"] = "RParen";
+    TokenKind["LBrace"] = "LBrace";
+    TokenKind["RBrace"] = "RBrace";
+    TokenKind["LBracket"] = "LBracket";
+    TokenKind["RBracket"] = "RBracket";
+    TokenKind["Comma"] = "Comma";
+    TokenKind["Colon"] = "Colon";
+    TokenKind["Semicolon"] = "Semicolon";
+    TokenKind["Dot"] = "Dot";
+    TokenKind["Arrow"] = "Arrow";
+    TokenKind["Underscore"] = "Underscore";
+    // Operators
+    TokenKind["Plus"] = "Plus";
+    TokenKind["Minus"] = "Minus";
+    TokenKind["Star"] = "Star";
+    TokenKind["Slash"] = "Slash";
+    TokenKind["Percent"] = "Percent";
+    TokenKind["Assign"] = "Assign";
+    TokenKind["Eq"] = "Eq";
+    TokenKind["NotEq"] = "NotEq";
+    TokenKind["Lt"] = "Lt";
+    TokenKind["Gt"] = "Gt";
+    TokenKind["LtEq"] = "LtEq";
+    TokenKind["GtEq"] = "GtEq";
+    TokenKind["AndAnd"] = "AndAnd";
+    TokenKind["OrOr"] = "OrOr";
+    TokenKind["Not"] = "Not";
+    TokenKind["EOF"] = "EOF";
+})(TokenKind || (TokenKind = {}));

package/dist/types.js

@@ -0,0 +1,108 @@
+export const NUMBER = { kind: "number" };
+export const STRING = { kind: "string" };
+export const BOOL = { kind: "bool" };
+export const VOID = { kind: "void" };
+export const UNKNOWN = { kind: "unknown" };
+export function arrayOf(element) {
+    return { kind: "array", element };
+}
+export function classType(name) {
+    return { kind: "class", name };
+}
+export function interfaceType(name) {
+    return { kind: "interface", name };
+}
+export function enumType(name) {
+    return { kind: "enum", name };
+}
+export function functionType(params, returnType) {
+    return { kind: "function", params, returnType };
+}
+export function taskType(resultType) {
+    return { kind: "task", resultType };
+}
+export function stateType(valueType) {
+    return { kind: "state", valueType };
+}
+export function typeToString(t) {
+    switch (t.kind) {
+        case "number":
+        case "string":
+        case "bool":
+        case "void":
+        case "unknown":
+            return t.kind;
+        case "array":
+            return `${typeToString(t.element)}[]`;
+        case "class":
+        case "interface":
+        case "enum":
+            return t.name;
+        case "function":
+            return `(${t.params.map(typeToString).join(", ")}) => ${typeToString(t.returnType)}`;
+        case "task":
+            return t.resultType.kind === "void" ? "task" : `task<${typeToString(t.resultType)}>`;
+        case "state":
+            return `state<${typeToString(t.valueType)}>`;
+    }
+}
+const PRIMITIVE_NAMES = new Set(["number", "string", "bool", "void"]);
+// Resolves a syntactic type annotation to a Type, given the kind of every known
+// user-declared name (class, interface, or enum).
+export function resolveTypeNode(node, namedTypes) {
+    if (node.kind === "ArrayType") {
+        const element = resolveTypeNode(node.element, namedTypes);
+        return element ? arrayOf(element) : null;
+    }
+    if (node.kind === "FunctionType") {
+        const params = [];
+        for (const p of node.params) {
+            const resolved = resolveTypeNode(p, namedTypes);
+            if (!resolved)
+                return null;
+            params.push(resolved);
+        }
+        const returnType = resolveTypeNode(node.returnType, namedTypes);
+        return returnType ? functionType(params, returnType) : null;
+    }
+    if (node.kind === "TaskType") {
+        const resultType = resolveTypeNode(node.resultType, namedTypes);
+        return resultType ? taskType(resultType) : null;
+    }
+    if (node.kind === "StateType") {
+        const valueType = resolveTypeNode(node.valueType, namedTypes);
+        return valueType ? stateType(valueType) : null;
+    }
+    if (PRIMITIVE_NAMES.has(node.name)) {
+        return { kind: node.name };
+    }
+    const kind = namedTypes.get(node.name);
+    if (kind === "class")
+        return classType(node.name);
+    if (kind === "interface")
+        return interfaceType(node.name);
+    if (kind === "enum")
+        return enumType(node.name);
+    return null;
+}
+export function typesEqual(a, b) {
+    if (a.kind === "unknown" || b.kind === "unknown")
+        return true;
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === "array" && b.kind === "array")
+        return typesEqual(a.element, b.element);
+    if (a.kind === "function" && b.kind === "function") {
+        return a.params.length === b.params.length && a.params.every((p, i) => typesEqual(p, b.params[i])) && typesEqual(a.returnType, b.returnType);
+    }
+    if (a.kind === "task" && b.kind === "task") {
+        return typesEqual(a.resultType, b.resultType);
+    }
+    if (a.kind === "state" && b.kind === "state") {
+        return typesEqual(a.valueType, b.valueType);
+    }
+    if ((a.kind === "class" || a.kind === "interface" || a.kind === "enum") && "name" in b) {
+        return a.name === b.name;
+    }
+    return true;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "kopscript",
+  "version": "0.1.0",
+  "description": "KopScript: a small OOP, strongly-typed language that transpiles to JavaScript",
+  "type": "module",
+  "license": "MIT",
+  "author": "Joe Koppin <koppinjo@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://dev.azure.com/koppinator/Koppindependence/_git/Kop"
+  },
+  "keywords": [
+    "language",
+    "compiler",
+    "transpiler",
+    "typescript",
+    "javascript"
+  ],
+  "main": "./dist/modules.js",
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "bin": {
+    "ks": "bin/ks.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "ks": "tsx src/cli.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}