kimchilang 1.0.1 → 1.0.2

package/README.md

@@ -334,6 +334,20 @@ sum(1, 2, 3, 4, 5)  // 15
 fn log(prefix, separator = ": ", ...messages) {
   return prefix + separator + messages.join(", ")
 }
+
+// Parameter destructuring - objects
+fn greetPerson({ name, age }) {
+  print "Hello, " + name + "! You are " + age
+}
+
+greetPerson({ name: "Alice", age: 30 })
+
+// Parameter destructuring - arrays
+fn swap([a, b]) {
+  return [b, a]
+}
+
+swap([1, 2])  // [2, 1]
 ```
 
 ### Enums

package/create-kimchi-app/package.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "description": "Create a new KimchiLang application",
   "bin": {
-    "create-kimchi-app": "./index.js"
+    "create-kimchi-app": "index.js"
   },
   "type": "module",
   "keywords": [
@@ -17,6 +17,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/kimchilang/kimchilang"
+    "url": "git+https://github.com/kimchilang/kimchilang.git"
   }
 }

package/install-kimchilang/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+};
+
+function log(message, color = '') {
+  console.log(color + message + COLORS.reset);
+}
+
+function run(command, options = {}) {
+  try {
+    execSync(command, { stdio: 'inherit', ...options });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function showHelp() {
+  log('\n🌶️  install-kimchilang\n', COLORS.bright + COLORS.cyan);
+  log('Install KimchiLang globally on your system.\n');
+  log('Usage:');
+  log('  npx install-kimchilang');
+  log('  npx install-kimchilang --help\n');
+}
+
+// Main
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  showHelp();
+  process.exit(0);
+}
+
+log('\n🌶️  Installing KimchiLang...\n', COLORS.bright + COLORS.cyan);
+
+// Install kimchilang globally
+log('Installing kimchilang globally...', COLORS.yellow);
+
+if (run('npm install -g kimchilang')) {
+  log('\n✨ KimchiLang installed successfully!\n', COLORS.bright + COLORS.green);
+  log('You can now use:', COLORS.cyan);
+  log('  kimchi --help              Show help');
+  log('  kimchi src.main            Run a module');
+  log('  kimchi compile app.km      Compile a file');
+  log('  npx create-kimchi-app      Create a new project\n');
+} else {
+  log('\n❌ Installation failed.\n', COLORS.red);
+  log('Try running with sudo:', COLORS.yellow);
+  log('  sudo npm install -g kimchilang\n');
+  process.exit(1);
+}

package/install-kimchilang/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "install-kimchilang",
+  "version": "1.0.1",
+  "description": "Install KimchiLang globally",
+  "bin": {
+    "install-kimchilang": "index.js"
+  },
+  "type": "module",
+  "keywords": [
+    "kimchi",
+    "kimchilang",
+    "install",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danajanezic/kimchilang.git"
+  }
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "kimchilang",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A modern programming language that transpiles to JavaScript",
   "main": "src/index.js",
   "bin": {
-    "kimchi": "./src/cli.js"
+    "kimchi": "src/cli.js"
   },
   "scripts": {
     "build": "node src/cli.js build",
@@ -17,13 +17,7 @@
     "javascript",
     "compiler"
   ],
-  "author": "KimchiLang Team",
+  "author": "Dana Janezic",
   "license": "MIT",
-  "type": "module",
-  "dependencies": {
-    "acorn": "^8.15.0"
-  },
-  "devDependencies": {
-    "is-odd": "^3.0.1"
-  }
+  "type": "module"
 }

package/src/generator.js

@@ -700,6 +700,30 @@ export class CodeGenerator {
       if (p.type === 'RestElement') {
         return `...${p.argument}`;
       }
+      
+      // Handle destructuring patterns
+      if (p.destructuring === 'object') {
+        const props = p.pattern.properties.map(prop => prop.key).join(', ');
+        const pattern = `{ ${props} }`;
+        if (p.defaultValue) {
+          return `${pattern} = ${this.visitExpression(p.defaultValue)}`;
+        }
+        return pattern;
+      }
+      
+      if (p.destructuring === 'array') {
+        const elems = p.pattern.elements.map(elem => {
+          if (elem === null) return '';
+          if (elem.type === 'Identifier') return elem.name;
+          return this.visitExpression(elem);
+        }).join(', ');
+        const pattern = `[${elems}]`;
+        if (p.defaultValue) {
+          return `${pattern} = ${this.visitExpression(p.defaultValue)}`;
+        }
+        return pattern;
+      }
+      
       if (p.defaultValue) {
         return `${p.name} = ${this.visitExpression(p.defaultValue)}`;
       }

package/src/parser.js

@@ -544,6 +544,28 @@ export class Parser {
           break;
         }
         
+        // Check for object destructuring pattern: { a, b }
+        if (this.check(TokenType.LBRACE)) {
+          const pattern = this.parseObjectPattern();
+          let defaultValue = null;
+          if (this.match(TokenType.ASSIGN)) {
+            defaultValue = this.parseExpression();
+          }
+          params.push({ pattern, defaultValue, destructuring: 'object' });
+          continue;
+        }
+        
+        // Check for array destructuring pattern: [a, b]
+        if (this.check(TokenType.LBRACKET)) {
+          const pattern = this.parseArrayPattern();
+          let defaultValue = null;
+          if (this.match(TokenType.ASSIGN)) {
+            defaultValue = this.parseExpression();
+          }
+          params.push({ pattern, defaultValue, destructuring: 'array' });
+          continue;
+        }
+        
         const name = this.expect(TokenType.IDENTIFIER, 'Expected parameter name').value;
         let defaultValue = null;
         

package/src/typechecker.js

@@ -398,6 +398,23 @@ export class TypeChecker {
     
     // Define parameters in scope
     for (const param of node.params) {
+      // Handle destructuring patterns
+      if (param.destructuring === 'object' && param.pattern) {
+        for (const prop of param.pattern.properties) {
+          this.defineVariable(prop.key, this.createType(Type.Any));
+        }
+        continue;
+      }
+      
+      if (param.destructuring === 'array' && param.pattern) {
+        for (const elem of param.pattern.elements) {
+          if (elem && elem.type === 'Identifier') {
+            this.defineVariable(elem.name, this.createType(Type.Any));
+          }
+        }
+        continue;
+      }
+      
       const name = param.name || param.argument;
       let paramType = this.createType(Type.Any);