feat: implement type annotations and return statements in parser

Author: JoelDeonDsouza

deno.lock

@@ -14,6 +14,9 @@ export default defineConfig([
   {
     rules: {
       "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": "warn",
+      "@typescript-eslint/no-empty-object-type": "warn",
+      "@typescript-eslint/prefer-as-const": "warn",
     },
   },
 ]);

eslint.config.ts

@@ -12,6 +12,7 @@ async function repl() {
     const input = prompt("> ");
     if (!input || input.includes("exit")) {
       process.exit(1);
+      // Deno.exit(1);
     }
     const program = parser.proTypeAsst(input);
     const results = evaluate(program, env);

main.ts

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname, relative, resolve } from "node:path";
+import { join, dirname, relative } from "node:path";
 import { glob } from "glob";
 import Parser from "../parser/parser";
 import { transpileToJS } from "../compiler/transpiler";

src/cli/jistc.ts

@@ -10,6 +10,7 @@ import {
   ObjectLiteral,
   ArrayLiteral,
   AssignmentExpr,
+  TypeAnnotation,
 } from "../parser/typeAst";
 
 interface TranspileOptions {
@@ -23,13 +24,60 @@ interface TranspileOptions {
 export function transpileToJS(ast: Program, options: TranspileOptions = {}): string {
   const ctx = new TranspileContext(options);
   const programCode = transpileProgram(ast, ctx);
-  // Mark function runtime  //
+
+  // State management runtime //
   const runtime =
     options.injectRuntime !== false
       ? `// JistScript Runtime
 const mark = typeof window !== 'undefined' && window.console
   ? (...args) => console.log('[JistScript]', ...args)
   : (...args) => console.log('[JistScript]', ...args);
+
+// State management system
+const __jist_state_counter = { value: 0 };
+const __jist_state_store = new Map();
+const __jist_component_states = new Map();
+
+function useState(initialValue, typeInfo) {
+  const stateId = __jist_state_counter.value++;
+
+  if (!__jist_state_store.has(stateId)) {
+    __jist_state_store.set(stateId, initialValue);
+  }
+
+  const currentValue = __jist_state_store.get(stateId);
+
+  const setState = (newValue) => {
+    if (typeInfo && !validateType(newValue, typeInfo)) {
+      console.warn(\`[JistScript] Type mismatch: expected \${typeInfo.type}, got \${typeof newValue}\`);
+    }
+    __jist_state_store.set(stateId, newValue);
+    return newValue;
+  };
+
+  return [currentValue, setState];
+}
+
+function validateType(value, typeInfo) {
+  switch (typeInfo.type) {
+    case 'String':
+      return typeof value === 'string';
+    case 'Number':
+      return typeof value === 'number';
+    case 'Boolean':
+      return typeof value === 'boolean';
+    case 'Array':
+      if (!Array.isArray(value)) return false;
+      if (typeInfo.elementType) {
+        return value.every(item => validateType(item, { type: typeInfo.elementType }));
+      }
+      return true;
+    case 'Object':
+      return typeof value === 'object' && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+}
 `
       : "";
 
@@ -61,6 +109,11 @@ function transpileStatement(stmt: Statement, ctx: TranspileContext): string {
     case "VarDeclaration": {
       const decl = stmt as VarDeclaration;
       const keyword = decl.constant ? "const" : "let";
+      if (decl.destructuring && decl.value) {
+        const elements = decl.destructuring.elements.map(e => e.symbol).join(", ");
+        const value = transpileExpression(decl.value, ctx);
+        return `${indent}${keyword} [${elements}] = ${value};`;
+      }
       const value = decl.value ? transpileExpression(decl.value, ctx) : "undefined";
       return `${indent}${keyword} ${decl.identifier} = ${value};`;
     }
@@ -118,6 +171,11 @@ function transpileExpression(expr: Expression, ctx: TranspileContext): string {
     case "CallExpr": {
       const call = expr as CallExpr;
       const caller = transpileExpression(call.caller, ctx);
+      if (caller === "useState" && call.typeAnnotation) {
+        const typeInfo = transpileTypeAnnotation(call.typeAnnotation);
+        const args = call.args.map(arg => transpileExpression(arg, ctx)).join(", ");
+        return `useState(${args}, ${typeInfo})`;
+      }
       const args = call.args.map(arg => transpileExpression(arg, ctx)).join(", ");
       return `${caller}(${args})`;
     }
@@ -153,3 +211,14 @@ function transpileExpression(expr: Expression, ctx: TranspileContext): string {
       return `/* Unknown: ${expr.kind} */`;
   }
 }
+
+function transpileTypeAnnotation(typeAnnotation: TypeAnnotation): string {
+  let typeInfo = `{ type: "${typeAnnotation.typeName}"`;
+  if (typeAnnotation.genericTypes && typeAnnotation.genericTypes.length > 0) {
+    const elementType = typeAnnotation.genericTypes[0].typeName;
+    typeInfo += `, elementType: "${elementType}"`;
+  }
+
+  typeInfo += " }";
+  return typeInfo;
+}

src/compiler/transpiler.ts

@@ -17,6 +17,7 @@ export enum TokenType {
   Colon,
   Dot,
   StringLiteral,
+  TypeAnnotation,
   EOF,
 }
 
@@ -26,6 +27,9 @@ const ReservedKeywords: Record<string, TokenType> = {
   function: TokenType.Function,
 };
 
+// Built-in type keywords //
+const TypeKeywords = new Set(["String", "Number", "Boolean", "Array", "Object", "Any", "Void"]);
+
 export interface Token {
   value: string;
   type: TokenType;
@@ -37,7 +41,7 @@ function createToken(value: string, type: TokenType): Token {
 
 function isAlphabetic(char: string): boolean {
   const code = char.charCodeAt(0);
-  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || char === "_";
 }
 
 function isSkippable(char: string): boolean {
@@ -48,6 +52,10 @@ function isInt(char: string): boolean {
   return /^[0-9]+$/.test(char);
 }
 
+function isAlphaNumeric(char: string): boolean {
+  return isAlphabetic(char) || isInt(char);
+}
+
 export function tokenize(sourceCode: string): Token[] {
   const tokens: Token[] = [];
   const src: string[] = sourceCode.split("");
@@ -108,26 +116,31 @@ export function tokenize(sourceCode: string): Token[] {
       default:
         if (isInt(char)) {
           let num = char;
-          while (src.length > 0 && isInt(src[0])) {
+          while (src.length > 0 && (isInt(src[0]) || src[0] === ".")) {
             num += src.shift()!;
           }
           tokens.push(createToken(num, TokenType.Number));
         } else if (isAlphabetic(char)) {
           let ident = char;
-          while (src.length > 0 && isAlphabetic(src[0])) {
+          while (src.length > 0 && isAlphaNumeric(src[0])) {
             ident += src.shift()!;
           }
-          const reserved = ReservedKeywords[ident];
-          if (reserved !== undefined) {
-            tokens.push(createToken(ident, reserved));
+          if (TypeKeywords.has(ident)) {
+            tokens.push(createToken(ident, TokenType.TypeAnnotation));
           } else {
-            tokens.push(createToken(ident, TokenType.Identifier));
+            const reserved = ReservedKeywords[ident];
+            if (reserved !== undefined) {
+              tokens.push(createToken(ident, reserved));
+            } else {
+              tokens.push(createToken(ident, TokenType.Identifier));
+            }
           }
         } else if (isSkippable(char)) {
           continue;
         } else {
           console.error("Unrecognized character found in source:", char.charCodeAt(0), char);
           process.exit(1);
+          // Deno.exit(1);
         }
     }
   }