@shd101wyy/yo 0.0.27 → 0.0.29

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/build.yo

@@ -0,0 +1,287 @@
+// Build System Module
+//
+// Provides the declarative build API for Yo projects.
+// All functions are compile-time only — they register build artifacts
+// and steps that the build runner uses to orchestrate compilation.
+//
+// Usage in build.yo:
+//   build :: import "std/build";
+//   build.project({ name: "my-app", root: "./src/lib.yo" });
+//   exe :: build.executable({ name: "my-app", root: "./src/main.yo" });
+//   install :: build.step("install", "Build all artifacts");
+//   install.depend_on(exe);
+
+// ── Optimization levels ──────────────────────────────────────────────
+
+Optimize :: enum(
+  Debug,
+  ReleaseSafe,
+  ReleaseFast,
+  ReleaseSmall
+);
+export Optimize;
+
+// ── Memory allocators ────────────────────────────────────────────────
+
+Allocator :: enum(
+  Mimalloc,
+  Libc
+);
+export Allocator;
+
+// ── Sanitizers ───────────────────────────────────────────────────────
+
+Sanitize :: enum(
+  None,
+  Address,
+  Leak
+);
+export Sanitize;
+
+// ── Step kinds ───────────────────────────────────────────────────────
+
+StepKind :: enum(
+  Executable,
+  StaticLibrary,
+  SharedLibrary,
+  SystemLibrary,
+  TestSuite,
+  Run,
+  Custom
+);
+export StepKind;
+
+// ── Target utilities ─────────────────────────────────────────────────
+
+target_host :: __yo_build_target_host();
+export target_host;
+
+// ── Config struct types ──────────────────────────────────────────────
+// Struct types with defaults, like Zig's options structs.
+// Usage: build.executable({ name: "app", root: "./src/main.yo" })
+// Unspecified fields get their default values.
+
+Project :: struct(
+  name : comptime_string,
+  (root : comptime_string) ?= "./src/lib.yo"
+);
+export Project;
+
+Executable :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug,
+  (allocator : Allocator) ?= Allocator.Mimalloc,
+  (sanitize : Sanitize) ?= Sanitize.None
+);
+export Executable;
+
+StaticLibrary :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug
+);
+export StaticLibrary;
+
+SharedLibrary :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug
+);
+export SharedLibrary;
+
+TestSuite :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host()
+);
+export TestSuite;
+
+// ── Step type ────────────────────────────────────────────────────────
+// Returned by all build functions. Used to wire dependencies between steps.
+
+Step :: struct(
+  name : comptime_string,
+  kind : StepKind
+);
+export Step;
+
+// ── Step methods ─────────────────────────────────────────────────────
+// Methods on Step for Zig-like API: step.depend_on(other), exe.link(lib).
+
+impl(Step,
+  depend_on : (fn(comptime(self) : Self, comptime(dep) : Step) -> comptime(unit))({
+    __yo_build_step_depend_on(self.name, dep.name, dep.kind);
+  }),
+  link : (fn(comptime(self) : Self, comptime(library) : Step) -> comptime(unit))({
+    __yo_build_link(self.name, library.name);
+  })
+);
+
+// ── Build option config types ────────────────────────────────────────
+// Like Zig's b.option(), declare user-configurable options.
+// CLI usage: yo build -Dname=value
+
+BuildOption :: struct(
+  name : comptime_string,
+  description : comptime_string,
+  (default : comptime_string) ?= ""
+);
+export BuildOption;
+
+// ── Dependency config types ──────────────────────────────────────────
+
+GitDependency :: struct(
+  name : comptime_string,
+  url : comptime_string,
+  (ref : comptime_string) ?= "HEAD",
+  (path : comptime_string) ?= ""
+);
+export GitDependency;
+
+PathDependency :: struct(
+  name : comptime_string,
+  path : comptime_string
+);
+export PathDependency;
+
+SystemLibrary :: struct(
+  name : comptime_string,
+  pkg_config : comptime_string,
+  (fallback_include : comptime_string) ?= "",
+  (fallback_lib : comptime_string) ?= "",
+  (fallback_link : comptime_string) ?= ""
+);
+export SystemLibrary;
+
+// ── Dependency handle ────────────────────────────────────────────────
+// Returned by build.dependency() and build.path_dependency().
+// Provides access to artifacts defined in the dependency's build.yo.
+
+Dependency :: struct(
+  name : comptime_string
+);
+export Dependency;
+
+impl(Dependency,
+  // Access a named artifact from the dependency's build.yo.
+  // Returns a Step that can be linked to the consumer's artifacts.
+  artifact : (fn(comptime(self) : Self, comptime(artifact_name) : comptime_string) -> comptime(Step))({
+    __yo_build_dep_artifact(self.name, artifact_name);
+    Step(name: artifact_name, kind: StepKind.StaticLibrary)
+  })
+);
+
+// ── Build functions ──────────────────────────────────────────────────
+// All registration functions return a Step value, allowing steps to be
+// wired together as dependencies via step.depend_on(dep).
+
+// Register project metadata.
+project :: (fn(comptime(config) : Project) -> comptime(unit)) {
+  __yo_build_project(config.name, config.root);
+};
+export project;
+
+// Register an executable artifact. Returns a Step for dependency wiring.
+executable :: (fn(comptime(config) : Executable) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  alloc_str :: match(config.allocator,
+    .Mimalloc => "mimalloc",
+    .Libc => "libc"
+  );
+  san_str :: match(config.sanitize,
+    .None => "none",
+    .Address => "address",
+    .Leak => "leak"
+  );
+  __yo_build_executable(config.name, config.root, config.target, opt_str, alloc_str, san_str);
+  Step(name: config.name, kind: StepKind.Executable)
+};
+export executable;
+
+// Register a static library artifact. Returns a Step for dependency wiring.
+static_library :: (fn(comptime(config) : StaticLibrary) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  __yo_build_static_library(config.name, config.root, config.target, opt_str);
+  Step(name: config.name, kind: StepKind.StaticLibrary)
+};
+export static_library;
+
+// Register a shared/dynamic library artifact. Returns a Step for dependency wiring.
+shared_library :: (fn(comptime(config) : SharedLibrary) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  __yo_build_shared_library(config.name, config.root, config.target, opt_str);
+  Step(name: config.name, kind: StepKind.SharedLibrary)
+};
+export shared_library;
+
+// Register a test suite. Returns a Step for dependency wiring.
+test :: (fn(comptime(config) : TestSuite) -> comptime(Step)) {
+  __yo_build_test(config.name, config.root, config.target);
+  Step(name: config.name, kind: StepKind.TestSuite)
+};
+export test;
+
+// Create a run step (compile + execute an artifact). Returns a Step.
+run :: (fn(comptime(artifact) : Step) -> comptime(Step)) {
+  __yo_build_run(artifact.name);
+  Step(name: artifact.name, kind: StepKind.Run)
+};
+export run;
+
+// Register a named build step. Use step.depend_on(dep) to add dependencies.
+step :: (fn(
+  comptime(name) : comptime_string,
+  comptime(description) : comptime_string
+) -> comptime(Step)) {
+  __yo_build_step(name, description);
+  Step(name: name, kind: StepKind.Custom)
+};
+export step;
+
+// Register a git-hosted dependency. Returns a Dependency handle for accessing artifacts.
+dependency :: (fn(comptime(config) : GitDependency) -> comptime(Dependency)) {
+  __yo_build_dependency(config.name, config.url, config.ref, config.path);
+  Dependency(name: config.name)
+};
+export dependency;
+
+// Register a local path dependency. Returns a Dependency handle for accessing artifacts.
+path_dependency :: (fn(comptime(config) : PathDependency) -> comptime(Dependency)) {
+  __yo_build_path_dependency(config.name, config.path);
+  Dependency(name: config.name)
+};
+export path_dependency;
+
+// Register a system C library discovered via pkg-config. Returns a Step for linking.
+system_library :: (fn(comptime(config) : SystemLibrary) -> comptime(Step)) {
+  __yo_build_system_library(config.name, config.pkg_config, config.fallback_include, config.fallback_lib, config.fallback_link);
+  Step(name: config.name, kind: StepKind.SystemLibrary)
+};
+export system_library;
+
+// Declare a user-configurable build option.
+// Returns the option value (from CLI -Dname=value, or the default).
+// Usage: strip :: build.option({ name: "strip", description: "Strip debug symbols", default: "false" });
+option :: (fn(comptime(config) : BuildOption) -> comptime(str))(
+  __yo_build_option(config.name, config.description, config.default)
+);
+export option;

package/std/crypto/random.yo

@@ -56,10 +56,10 @@ extern "Yo",
 
 random_bytes :: (fn(buf: *(u8), size: usize, using(exn : Exception)) -> unit)(
   cond(
-    (platform == Platform.Darwin) => {
+    (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf, size);
     },
-    (platform == Platform.Win32) => {
+    (platform == Platform.Windows) => {
       r := __yo_bcrypt_gen_random(buf, u32(size));
       cond(
         (r == i32(0)) => (),

package/std/fs/dir.yo

@@ -105,7 +105,7 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
             // On Windows, skip past drive letter root (e.g., "C:\")
             // to avoid trying to mkdir "C:" which fails with EACCES
             cond(
-              (platform == Platform.Win32) => {
+              (platform == Platform.Windows) => {
                 cond(
                   (bytes.len() >= usize(3)) => {
                     first := bytes.get(usize(0)).unwrap();

package/std/fs/temp.yo

@@ -34,7 +34,7 @@ IO_file :: import "../sys/file";
 
 _default_tmp_dir :: (fn() -> String)(
   cond(
-    (platform == Platform.Win32) => {
+    (platform == Platform.Windows) => {
       temp := env.get(`TEMP`);
       match(temp,
         .Some(v) => v,

package/std/os/env.yo

@@ -18,7 +18,7 @@ open import "../string";
 // Return the current user's home directory, or .None if unavailable.
 home_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => match(env.get(`USERPROFILE`),
+    (platform == Platform.Windows) => match(env.get(`USERPROFILE`),
       .Some(p) => .Some(p),
       .None    => match(env.get(`HOMEDRIVE`),
         .None => .None,
@@ -37,7 +37,7 @@ home_dir :: (fn() -> Option(String))(
 //   Windows:     %APPDATA%
 config_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => env.get(`APPDATA`),
+    (platform == Platform.Windows) => env.get(`APPDATA`),
     true => match(env.get(`XDG_CONFIG_HOME`),
       .Some(d) => .Some(d),
       .None => match(home_dir(),
@@ -54,8 +54,8 @@ config_dir :: (fn() -> Option(String))(
 //   Windows: %LOCALAPPDATA%
 cache_dir :: (fn() -> Option(String))(
   cond(
-    (platform == Platform.Win32) => env.get(`LOCALAPPDATA`),
-    (platform == Platform.Darwin) => match(home_dir(),
+    (platform == Platform.Windows) => env.get(`LOCALAPPDATA`),
+    (platform == Platform.Macos) => match(home_dir(),
       .None => .None,
       .Some(h) => .Some(h.concat(`/Library/Caches`))
     ),
@@ -72,7 +72,7 @@ cache_dir :: (fn() -> Option(String))(
 // Return the system temporary directory.
 temp_dir :: (fn() -> String)(
   cond(
-    (platform == Platform.Win32) => match(env.get(`TEMP`),
+    (platform == Platform.Windows) => match(env.get(`TEMP`),
       .Some(t) => t,
       .None    => `C:\Temp`
     ),

package/std/os/signal.yo

@@ -35,35 +35,35 @@ export Signal;
 _signal_num :: (fn(sig: Signal) -> i32)(
   match(sig,
     .Interrupt => cond(
-      (platform == Platform.Darwin) => i32(2),
+      (platform == Platform.Macos) => i32(2),
       true => i32(2)
     ),
     .Terminate => cond(
-      (platform == Platform.Darwin) => i32(15),
+      (platform == Platform.Macos) => i32(15),
       true => i32(15)
     ),
     .Hangup => cond(
-      (platform == Platform.Darwin) => i32(1),
+      (platform == Platform.Macos) => i32(1),
       true => i32(1)
     ),
     .User1 => cond(
-      (platform == Platform.Darwin) => i32(30),
+      (platform == Platform.Macos) => i32(30),
       true => i32(10)
     ),
     .User2 => cond(
-      (platform == Platform.Darwin) => i32(31),
+      (platform == Platform.Macos) => i32(31),
       true => i32(12)
     ),
     .Pipe => cond(
-      (platform == Platform.Darwin) => i32(13),
+      (platform == Platform.Macos) => i32(13),
       true => i32(13)
     ),
     .Alarm => cond(
-      (platform == Platform.Darwin) => i32(14),
+      (platform == Platform.Macos) => i32(14),
       true => i32(14)
     ),
     .Child => cond(
-      (platform == Platform.Darwin) => i32(20),
+      (platform == Platform.Macos) => i32(20),
       true => i32(17)
     )
   )

package/std/path.yo

@@ -21,7 +21,7 @@ export PathError;
  * TODO: Support Windows paths later
  */
 PATH_SEPARATOR :: cond(
-  (__yo_process_platform() == "win32") => u8(92),  // '\' for Windows
+  (__yo_process_platform() == "windows") => u8(92),  // '\' for Windows
   true => u8(47)  // '/' for Unix
 );
 export PATH_SEPARATOR;
@@ -32,7 +32,7 @@ export PATH_SEPARATOR;
  * TODO: Support Windows paths later
  */
 PATH_DELIMITER :: cond(
-  (__yo_process_platform() == "win32") => u8(59),  // ';' for Windows
+  (__yo_process_platform() == "windows") => u8(59),  // ';' for Windows
   true => u8(58)  // ':' for Unix
 );
 export PATH_DELIMITER;

package/std/process.yo

@@ -8,64 +8,44 @@ open import "./path";
 { malloc, free } :: GlobalAllocator;
 
 /**
- * Currently follows node.js conventions.
- * Available platforms:
- * - "aix"
- * - "android"
- * - "darwin" (macOS)
- * - "freebsd"
+ * Target platform for the current compilation.
+ * Uses standard naming:
  * - "linux"
- * - "openbsd"
- * - "sunos"
- * - "win32" (even on 64-bit Windows)
+ * - "macos"
+ * - "windows"
+ * - "freebsd"
+ * - "wasi"
  */
 platform :: __yo_process_platform();
 export platform;
 
 Platform :: {
-  Aix : "aix",
-  Android : "android",
-  Darwin : "darwin",
-  FreeBSD : "freebsd",
   Linux : "linux",
-  OpenBSD : "openbsd",
-  SunOS : "sunos",
-  Win32 : "win32"
+  Macos : "macos",
+  Windows : "windows",
+  FreeBSD : "freebsd",
+  Wasi : "wasi"
 };
 export Platform;
 
 /**
- * Currently follows node.js conventions.
- * Available architectures:
+ * Target architecture for the current compilation.
+ * Uses standard naming:
+ * - "x86_64"
+ * - "aarch64"
+ * - "x86"
  * - "arm"
- * - "arm64"
- * - "ia32"
- * - "loong64"
- * - "mips"
- * - "mipsel"
- * - "ppc"
- * - "ppc64"
- * - "riscv64"
- * - "s390"
- * - "s390x"
- * - "x64"
+ * - "wasm32"
  */
 arch :: __yo_process_arch();
 export arch;
 
 Arch :: {
+  X86_64 : "x86_64",
+  Aarch64 : "aarch64",
+  X86 : "x86",
   Arm : "arm",
-  Arm64 : "arm64",
-  Ia32 : "ia32",
-  Loong64 : "loong64",
-  Mips : "mips",
-  Mipsel : "mipsel",
-  Ppc : "ppc",
-  Ppc64 : "ppc64",
-  Riscv64 : "riscv64",
-  S390 : "s390",
-  S390x : "s390x",
-  X64 : "x64"
+  Wasm32 : "wasm32"
 };
 export Arch;
 
@@ -140,7 +120,7 @@ env :: impl {
     value_cstr := value.to_cstr().ptr().unwrap();
     
     result := cond(
-      (platform == Platform.Win32) => {
+      (platform == Platform.Windows) => {
         // Windows: use _putenv_s (doesn't have overwrite parameter)
         { _putenv_s } :: import "./libc/windows";
         
@@ -180,7 +160,7 @@ export env;
  */
 cwd :: (fn() -> Result(Path, String))(
   cond(
-    (platform == Platform.Win32) => {
+    (platform == Platform.Windows) => {
       // Windows implementation using GetCurrentDirectoryW
       { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import "./libc/windows";
       
@@ -289,7 +269,7 @@ export cwd;
  */
 chdir :: (fn(path: Path) -> Result(unit, String))(
   cond(
-    (platform == Platform.Win32) => {
+    (platform == Platform.Windows) => {
       // Windows implementation using SetCurrentDirectoryA
       { SetCurrentDirectoryA, BOOL } :: import "./libc/windows";