freelang-v4 4.3.0

package/src/pattern-matching-jest.test.ts

@@ -0,0 +1,170 @@
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { Compiler } from "./compiler";
+import { VM } from "./vm";
+
+async function exec(source: string): Promise<{ output: string[]; error: string | null }> {
+  const { tokens, errors: lexErrors } = new Lexer(source).tokenize();
+  if (lexErrors.length > 0) throw new Error(`Lex: ${lexErrors[0].message}`);
+  const { program, errors: parseErrors } = new Parser(tokens).parse();
+  if (parseErrors.length > 0) throw new Error(`Parse: ${parseErrors[0].message}`);
+  const chunk = new Compiler().compile(program);
+  return await new VM().run(chunk);
+}
+
+describe("Pattern Matching Features - Guard & Destructuring", () => {
+  // T1: Guard 절 기본
+  it("T1: should support guard clause", async () => {
+    const code = `
+      fn test() -> i32 {
+        var x = 10
+        match x {
+          y if y > 5 => 100,
+          y if y < 5 => 50,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["100"]);
+  });
+
+  // T2: Guard 절에서 패턴 바인딩 사용
+  it("T2: should use bindings in guard clause", async () => {
+    const code = `
+      fn test() -> i32 {
+        match 42 {
+          x if x > 40 => x + 1,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["43"]);
+  });
+
+  // T3: 구조체 분해 패턴 (기본)
+  it("T3: should support struct destructuring", async () => {
+    const code = `
+      struct Point {
+        x: i32,
+        y: i32,
+      }
+
+      fn test() -> i32 {
+        var p = Point { x: 10, y: 20 }
+        match p {
+          Point { x, y } => x + y,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["30"]);
+  });
+
+  // T4: 구조체 분해 + Guard 절
+  it("T4: should combine struct destructuring with guard", async () => {
+    const code = `
+      struct Point {
+        x: i32,
+        y: i32,
+      }
+
+      fn test() -> i32 {
+        var p = Point { x: 10, y: 20 }
+        match p {
+          Point { x, y } if x > 5 => x + y,
+          Point { x, y } if x <= 5 => y - x,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["30"]);
+  });
+
+  // T5: 배열 분해 패턴 (기본)
+  it("T5: should support array destructuring", async () => {
+    const code = `
+      fn test() -> i32 {
+        var arr = [10, 20, 30]
+        match arr {
+          [a, b, c] => a + b + c,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["60"]);
+  });
+
+  // T6: 배열 분해 + 나머지 패턴
+  it("T6: should support rest pattern in array", async () => {
+    const code = `
+      fn test() -> i32 {
+        var arr = [10, 20, 30, 40]
+        match arr {
+          [a, .., b] => a + b,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["50"]);
+  });
+
+  // T7: 다중 조건 가드
+  it("T7: should support multiple guard conditions", async () => {
+    const code = `
+      fn categorize(x: i32) -> i32 {
+        match x {
+          y if y < 0 => -1,
+          0 => 0,
+          y if y > 0 => 1,
+          _ => 999,
+        }
+      }
+      println(str(categorize(42)))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["1"]);
+  });
+
+  // T8: 복잡한 중첩 패턴
+  it("T8: should support complex nested patterns", async () => {
+    const code = `
+      struct Point {
+        x: i32,
+        y: i32,
+      }
+
+      fn test() -> i32 {
+        var p = Some(Point { x: 5, y: 10 })
+        match p {
+          Some(Point { x, y }) if x > 0 => x + y,
+          Some(Point { x, y }) if x <= 0 => y - x,
+          None => -999,
+          _ => 0,
+        }
+      }
+      println(str(test()))
+    `;
+
+    const { output } = await exec(code);
+    expect(output).toEqual(["15"]);
+  });
+});

package/src/pkg/init.ts

@@ -0,0 +1,91 @@
+// freelang init [name] - Initialize a new FreeLang project
+
+import * as fs from "fs";
+import * as path from "path";
+import { stringifyTOML } from "./toml";
+
+export async function initProject(projectName: string = "my-app"): Promise<void> {
+  const projectPath = path.resolve(process.cwd(), projectName);
+
+  // Check if directory already exists
+  if (fs.existsSync(projectPath)) {
+    console.error(`Error: Directory '${projectName}' already exists`);
+    process.exit(1);
+  }
+
+  // Create project structure
+  fs.mkdirSync(projectPath, { recursive: true });
+  fs.mkdirSync(path.join(projectPath, "src"), { recursive: true });
+  fs.mkdirSync(path.join(projectPath, "tests"), { recursive: true });
+
+  // Create freelang.toml
+  const tomlContent = stringifyTOML({
+    package: {
+      name: projectName,
+      version: "0.1.0",
+      entry: "src/main.fl",
+    },
+    dependencies: {},
+    scripts: {
+      test: "freelang tests/main.fl",
+    },
+  });
+
+  fs.writeFileSync(path.join(projectPath, "freelang.toml"), tomlContent);
+
+  // Create main.fl
+  const mainContent = `// FreeLang v4 - ${projectName}
+
+fn main() -> () {
+  println("Hello from FreeLang!")
+}
+
+main()
+`;
+  fs.writeFileSync(path.join(projectPath, "src", "main.fl"), mainContent);
+
+  // Create test file
+  const testContent = `// Tests for ${projectName}
+
+fn test_basic() -> bool {
+  var x = 42
+  x == 42
+}
+
+// Run: freelang tests/main.fl
+`;
+  fs.writeFileSync(path.join(projectPath, "tests", "main.fl"), testContent);
+
+  // Create README.md
+  const readmeContent = `# ${projectName}
+
+A FreeLang v4 project.
+
+## Build
+
+\`\`\`bash
+freelang run build
+\`\`\`
+
+## Test
+
+\`\`\`bash
+freelang run test
+\`\`\`
+
+## Run
+
+\`\`\`bash
+freelang src/main.fl
+\`\`\`
+`;
+  fs.writeFileSync(path.join(projectPath, "README.md"), readmeContent);
+
+  console.log(`✓ Created project '${projectName}' at ${projectPath}`);
+  console.log("  - freelang.toml (project configuration)");
+  console.log("  - src/main.fl (entry point)");
+  console.log("  - tests/main.fl (test file)");
+  console.log("  - README.md (documentation)");
+  console.log("");
+  console.log(`Run 'cd ${projectName} && freelang src/main.fl' to get started!`);
+}

package/src/pkg/install.ts

@@ -0,0 +1,56 @@
+// freelang install <pkg> - Install a FreeLang package
+
+import * as fs from "fs";
+import * as path from "path";
+import { parseTOML, stringifyTOML } from "./toml";
+
+export async function installPackage(
+  packageName: string,
+  projectRoot: string,
+): Promise<void> {
+  const tomlPath = path.join(projectRoot, "freelang.toml");
+
+  // Read freelang.toml
+  if (!fs.existsSync(tomlPath)) {
+    console.error("Error: freelang.toml not found");
+    process.exit(1);
+  }
+
+  const tomlContent = fs.readFileSync(tomlPath, "utf-8");
+  const tomlData = parseTOML(tomlContent);
+
+  // Initialize dependencies if not present
+  if (!tomlData.dependencies) {
+    tomlData.dependencies = {};
+  }
+
+  // Check if package exists in registry
+  const registryPath = path.join(__dirname, "../../packages/registry.json");
+  if (!fs.existsSync(registryPath)) {
+    console.error("Error: Package registry not found");
+    process.exit(1);
+  }
+
+  const registry = JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+  const pkg = registry.packages[packageName];
+
+  if (!pkg) {
+    console.error(`Error: Package '${packageName}' not found in registry`);
+    process.exit(1);
+  }
+
+  // Add package to dependencies
+  tomlData.dependencies[packageName] = {
+    version: pkg.latest_version,
+    path: `../../packages/${packageName}/${pkg.latest_version}/src`,
+  };
+
+  // Write updated freelang.toml
+  const updatedToml = stringifyTOML(tomlData);
+  fs.writeFileSync(tomlPath, updatedToml);
+
+  console.log(`✓ Installed ${packageName}@${pkg.latest_version}`);
+  console.log(
+    `  Description: ${pkg.description}`,
+  );
+}

package/src/pkg/registry.ts

@@ -0,0 +1,103 @@
+// Package registry exploration
+
+import * as fs from "fs";
+import * as path from "path";
+
+export interface Package {
+  name: string;
+  description: string;
+  version: string;
+  author?: string;
+  repository?: string;
+}
+
+export interface PackageRegistry {
+  packages: {
+    [name: string]: {
+      name: string;
+      description: string;
+      latest_version: string;
+      versions: string[];
+      author?: string;
+      repository?: string;
+    };
+  };
+}
+
+export function getRegistry(): PackageRegistry {
+  const registryPath = path.join(__dirname, "../../packages/registry.json");
+
+  if (!fs.existsSync(registryPath)) {
+    return { packages: {} };
+  }
+
+  try {
+    const content = fs.readFileSync(registryPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { packages: {} };
+  }
+}
+
+export function listPackages(): void {
+  const registry = getRegistry();
+
+  if (Object.keys(registry.packages).length === 0) {
+    console.log("No packages available in registry");
+    return;
+  }
+
+  console.log("Available FreeLang packages:\n");
+
+  for (const [name, pkg] of Object.entries(registry.packages)) {
+    console.log(`${name}@${pkg.latest_version}`);
+    console.log(`  ${pkg.description}`);
+    if (pkg.author) {
+      console.log(`  By: ${pkg.author}`);
+    }
+    console.log("");
+  }
+}
+
+export function searchPackages(query: string): void {
+  const registry = getRegistry();
+  const results = Object.entries(registry.packages).filter(([name, pkg]) => {
+    return (
+      name.includes(query) ||
+      pkg.description.toLowerCase().includes(query.toLowerCase())
+    );
+  });
+
+  if (results.length === 0) {
+    console.log(`No packages found matching '${query}'`);
+    return;
+  }
+
+  console.log(`Found ${results.length} package(s) matching '${query}':\n`);
+
+  for (const [name, pkg] of results) {
+    console.log(`${name}@${pkg.latest_version}`);
+    console.log(`  ${pkg.description}`);
+    console.log("");
+  }
+}
+
+export function getPackageInfo(name: string): void {
+  const registry = getRegistry();
+  const pkg = registry.packages[name];
+
+  if (!pkg) {
+    console.error(`Package '${name}' not found`);
+    process.exit(1);
+  }
+
+  console.log(`${pkg.name}@${pkg.latest_version}`);
+  console.log(`${pkg.description}`);
+  if (pkg.author) {
+    console.log(`Author: ${pkg.author}`);
+  }
+  if (pkg.repository) {
+    console.log(`Repository: ${pkg.repository}`);
+  }
+  console.log(`Versions: ${pkg.versions.join(", ")}`);
+}

package/src/pkg/run.ts

@@ -0,0 +1,49 @@
+// freelang run <script> - Run script from freelang.toml
+
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { parseTOML } from "./toml";
+
+export async function runScript(
+  scriptName: string,
+  projectRoot: string,
+): Promise<void> {
+  const tomlPath = path.join(projectRoot, "freelang.toml");
+
+  // Read freelang.toml
+  if (!fs.existsSync(tomlPath)) {
+    console.error("Error: freelang.toml not found");
+    process.exit(1);
+  }
+
+  const tomlContent = fs.readFileSync(tomlPath, "utf-8");
+  const tomlData = parseTOML(tomlContent);
+
+  // Get script
+  if (!tomlData.scripts || !tomlData.scripts[scriptName]) {
+    console.error(`Error: Script '${scriptName}' not found in freelang.toml`);
+    console.log("Available scripts:");
+    if (tomlData.scripts) {
+      for (const [name] of Object.entries(tomlData.scripts)) {
+        console.log(`  - ${name}`);
+      }
+    }
+    process.exit(1);
+  }
+
+  const scriptCommand = tomlData.scripts[scriptName];
+
+  console.log(`> ${scriptCommand}`);
+  console.log("");
+
+  try {
+    execSync(scriptCommand, {
+      cwd: projectRoot,
+      stdio: "inherit",
+    });
+  } catch (error) {
+    console.error("Script failed");
+    process.exit(1);
+  }
+}

package/src/pkg/toml.ts

@@ -0,0 +1,129 @@
+// Lightweight TOML Parser (no external dependencies)
+
+export interface TomlValue {
+  [key: string]: any;
+}
+
+export function parseTOML(content: string): TomlValue {
+  const result: TomlValue = {};
+  const lines = content.split("\n");
+  let currentSection: string | null = null;
+  let currentObj: TomlValue = result;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+
+    // Skip empty lines and comments
+    if (!line || line.startsWith("#")) continue;
+
+    // Section header: [section]
+    if (line.startsWith("[") && line.endsWith("]")) {
+      currentSection = line.slice(1, -1).trim();
+      if (!result[currentSection]) {
+        result[currentSection] = {};
+      }
+      currentObj = result[currentSection];
+      continue;
+    }
+
+    // Key-value pairs: key = value
+    const eqIndex = line.indexOf("=");
+    if (eqIndex > 0) {
+      const key = line.substring(0, eqIndex).trim();
+      const valueStr = line.substring(eqIndex + 1).trim();
+      const value = parseValue(valueStr);
+      currentObj[key] = value;
+    }
+  }
+
+  return result;
+}
+
+function parseValue(valueStr: string): any {
+  // String values (double quotes)
+  if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+    return valueStr.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+
+  // String values (single quotes)
+  if (valueStr.startsWith("'") && valueStr.endsWith("'")) {
+    return valueStr.slice(1, -1);
+  }
+
+  // Boolean values
+  if (valueStr === "true") return true;
+  if (valueStr === "false") return false;
+
+  // Numeric values
+  if (!isNaN(Number(valueStr))) {
+    return Number(valueStr);
+  }
+
+  // Array values [item1, item2, ...]
+  if (valueStr.startsWith("[") && valueStr.endsWith("]")) {
+    const itemsStr = valueStr.slice(1, -1);
+    const items = itemsStr.split(",").map((item) => parseValue(item.trim()));
+    return items;
+  }
+
+  // Table values {key = value, ...}
+  if (valueStr.startsWith("{") && valueStr.endsWith("}")) {
+    const content = valueStr.slice(1, -1);
+    const obj: TomlValue = {};
+    const pairs = content.split(",");
+    for (const pair of pairs) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx > 0) {
+        const k = pair.substring(0, eqIdx).trim();
+        const v = pair.substring(eqIdx + 1).trim();
+        obj[k] = parseValue(v);
+      }
+    }
+    return obj;
+  }
+
+  // Return as string if no match
+  return valueStr;
+}
+
+export function stringifyTOML(obj: TomlValue, indent: number = 0): string {
+  const lines: string[] = [];
+  const indentStr = " ".repeat(indent);
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+
+    if (typeof value === "object" && !Array.isArray(value)) {
+      // Nested section
+      if (indent === 0) {
+        lines.push(`[${key}]`);
+      }
+      lines.push(stringifyTOML(value, indent + 2));
+    } else if (Array.isArray(value)) {
+      // Array
+      const items = value.map((v) => stringifyValue(v)).join(", ");
+      lines.push(`${indentStr}${key} = [${items}]`);
+    } else {
+      // Scalar value
+      lines.push(`${indentStr}${key} = ${stringifyValue(value)}`);
+    }
+  }
+
+  return lines.filter((l) => l).join("\n");
+}
+
+function stringifyValue(value: any): string {
+  if (typeof value === "string") {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => stringifyValue(v)).join(", ");
+    return `[${items}]`;
+  }
+  return String(value);
+}