v2: lots of fixes; macos module to generate objc in V

Author: medvednikov

cmd/v2/test_all.sh

@@ -1,7 +1,16 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-cd "$(dirname "$0")"
+script_dir="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+repo_root="$(CDPATH= cd -- "${script_dir}/../.." && pwd)"
+
+cd "${script_dir}"
+
+v1_compiler="${V:-${repo_root}/v}"
+if [ ! -x "${v1_compiler}" ]; then
+  echo "FAIL: v1 compiler not found: ${v1_compiler}"
+  exit 1
+fi
 
 # V1's formatter may clobber v2 source files during rebuild.
 # Back up the entire v2 tree and restore after each V1 build.
@@ -21,27 +30,31 @@ KNOWN_FAILURES=0
 
 echo "=== 1/14: ARM64 self-host hello world ==="
 backup_v2_src
-v -skip-unused -cc cc -o v2 v2.v
+"${v1_compiler}" -skip-unused -cc cc -o v2 v2.v
 restore_v2_src
-./v2 -backend arm64 -nocache -o v3 v2.v && ./v3 -o hello_arm hello.v && ./hello_arm
+./v2 -backend arm64 -gc none -nocache -o v3 v2.v
+./v3 -backend arm64 -o hello_arm hello.v
+./hello_arm
 
 echo ""
-echo "=== 2/14: ARM64 self-host chain (v2->v3->v4->v5, parallel) ==="
+echo "=== 2/14: ARM64 self-host chain (v2->v3->v4->v5->v6) ==="
 echo "  Building v3 from v2..."
-./v2 -nocache -backend arm64 -o v3_chain v2.v
+./v2 -nocache -gc none -backend arm64 -o v3_chain v2.v
 echo "  Building v4 from v3..."
 ./v3_chain -nocache -gc none -backend arm64 -o v4_chain v2.v
 echo "  Building v5 from v4..."
 ./v4_chain -nocache -gc none -backend arm64 -o v5_chain v2.v
-V4_SIZE=$(wc -c < v4_chain)
+echo "  Building v6 from v5..."
+./v5_chain -nocache -gc none -backend arm64 -o v6_chain v2.v
 V5_SIZE=$(wc -c < v5_chain)
-if [ "$V4_SIZE" -eq "$V5_SIZE" ]; then
-  echo "  v4=v5 ($V4_SIZE bytes) — chain converged"
+V6_SIZE=$(wc -c < v6_chain)
+if [ "$V5_SIZE" -eq "$V6_SIZE" ]; then
+  echo "  v5=v6 ($V5_SIZE bytes) — chain converged"
 else
-  echo "  FAIL: v4 ($V4_SIZE) != v5 ($V5_SIZE)"
+  echo "  FAIL: v5 ($V5_SIZE) != v6 ($V6_SIZE)"
   exit 1
 fi
-rm -f v3_chain v4_chain v5_chain
+rm -f v3_chain v4_chain v5_chain v6_chain
 
 echo ""
 echo "=== 3/14: Self-host test ==="
@@ -96,23 +109,23 @@ echo "=== 9/14: Sumtype tests (arm64) ==="
 
 echo ""
 echo "=== 10/14: SSA backends test (arm64) ==="
-v -gc none run test_ssa_backends.v arm64
+"${v1_compiler}" -gc none run test_ssa_backends.v arm64
 
 echo ""
 echo "=== 11/14: SSA backends test (cleanc) ==="
-v -gc none run test_ssa_backends.v cleanc
+"${v1_compiler}" -gc none run test_ssa_backends.v cleanc
 
 echo ""
 echo "=== 12/14: Transformer unit tests ==="
-v ../../vlib/v2/transformer/transformer_test.v
+"${v1_compiler}" ../../vlib/v2/transformer/transformer_test.v
 
 echo ""
 echo "=== 13/14: Transformer integration test ==="
-v ../../vlib/v2/transformer/transformer_v2_darwin_test.v
+"${v1_compiler}" ../../vlib/v2/transformer/transformer_v2_darwin_test.v
 
 echo ""
 echo "=== 14/14: Cleanc runtime tests ==="
-v -gc none run ../../vlib/v2/gen/cleanc/tests/run_tests.v
+"${v1_compiler}" -gc none run ../../vlib/v2/gen/cleanc/tests/run_tests.v
 
 echo ""
 if [ "$KNOWN_FAILURES" -gt 0 ]; then

vlib/db/pg/README.md

@@ -33,6 +33,10 @@ brew install postgresql
 brew services start postgresql
 ```
 
+On newer Homebrew setups the formula and service name may be versioned
+instead, for example `postgresql@18`. Use the exact name reported by
+`brew info postgresql`.
+
 ### MacOSX (MacPorts)
 
 ```
@@ -116,6 +120,10 @@ Read this section to learn how to install and connect to PostgreSQL
 [*Linux*](https://www.postgresqltutorial.com/postgresql-getting-started/install-postgresql-linux);
 [*macOS*](https://www.postgresqltutorial.com/postgresql-getting-started/install-postgresql-macos).
 
+When you use `pg.connect(pg.Config{ ... })`, empty `Config` fields are omitted from the
+generated libpq connection string. That lets libpq defaults, `PGPASSWORD`, and `.pgpass`
+apply when you do not set those fields in code.
+
 ## Using Parameterized Queries
 
 Parameterized queries (exec_param, etc.) in V require the use of the following syntax: ($n).

vlib/db/pg/pg.c.v

@@ -210,13 +210,57 @@ fn C.PQsocket(conn &C.PGconn) i32
 
 fn C.PQescapeLiteral(conn &C.PGconn, str &char, length usize) &char
 
+fn conninfo_needs_quotes(value string) bool {
+	for ch in value {
+		if ch.is_space() || ch == `'` || ch == `\\` {
+			return true
+		}
+	}
+	return false
+}
+
+fn escape_conninfo_value(value string) string {
+	if !conninfo_needs_quotes(value) {
+		return value
+	}
+	mut escaped := []u8{cap: value.len + 2}
+	escaped << `'`
+	for ch in value {
+		if ch == `\\` || ch == `'` {
+			escaped << `\\`
+		}
+		escaped << ch
+	}
+	escaped << `'`
+	return escaped.bytestr()
+}
+
+fn (config Config) conninfo() string {
+	mut parts := []string{cap: 5}
+	if config.host != '' {
+		parts << 'host=${escape_conninfo_value(config.host)}'
+	}
+	if config.port > 0 {
+		parts << 'port=${config.port}'
+	}
+	if config.user != '' {
+		parts << 'user=${escape_conninfo_value(config.user)}'
+	}
+	if config.dbname != '' {
+		parts << 'dbname=${escape_conninfo_value(config.dbname)}'
+	}
+	if config.password != '' {
+		parts << 'password=${escape_conninfo_value(config.password)}'
+	}
+	return parts.join(' ')
+}
+
 // connect makes a new connection to the database server using
 // the parameters from the `Config` structure, returning
-// a connection error when something goes wrong
+// a connection error when something goes wrong.
+// Empty fields are omitted so libpq defaults can still apply.
 pub fn connect(config Config) !DB {
-	conninfo := 'host=${config.host} port=${config.port} user=${config.user} dbname=${config.dbname} password=${config.password}'
-
-	return connect_with_conninfo(conninfo)!
+	return connect_with_conninfo(config.conninfo())!
 }
 
 // connect_with_conninfo makes a new connection to the database server using

vlib/goroutines/context_nix.h

@@ -0,0 +1,69 @@
+#ifndef GOROUTINES_CONTEXT_NIX_H
+#define GOROUTINES_CONTEXT_NIX_H
+
+#include <ucontext.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+// Extended context: ucontext_t + entry function info for first-time starts.
+typedef struct {
+    ucontext_t uctx;
+    void (*entry_fn)(void *);
+    void *entry_arg;
+} goroutine_ctx_t;
+
+// Thread-local pointer to the target goroutine context.
+// Set just before swapcontext/setcontext so the trampoline can find its fn/arg.
+#if defined(_WIN32) || defined(_WIN64)
+static __declspec(thread) goroutine_ctx_t *_goroutine_start_ctx = NULL;
+#else
+static _Thread_local goroutine_ctx_t *_goroutine_start_ctx = NULL;
+#endif
+
+static void *goroutines_context_alloc(void) {
+    return calloc(1, sizeof(goroutine_ctx_t));
+}
+
+// Zero-argument trampoline. Reads fn/arg from the TLS-stored context.
+// This avoids passing arguments through makecontext, which is broken on macOS ARM64.
+static void goroutines__context_trampoline(void) {
+    goroutine_ctx_t *gctx = _goroutine_start_ctx;
+    _goroutine_start_ctx = NULL;
+    void (*fn)(void *) = gctx->entry_fn;
+    void *arg = gctx->entry_arg;
+    // Clear so future context switches to this goroutine don't re-trigger
+    gctx->entry_fn = NULL;
+    gctx->entry_arg = NULL;
+    fn(arg);
+}
+
+static void goroutines_context_init(void *ctx_buf, void *stack, int stack_size, void *entry_fn, void *arg) {
+    goroutine_ctx_t *gctx = (goroutine_ctx_t *)ctx_buf;
+    gctx->entry_fn = (void (*)(void *))entry_fn;
+    gctx->entry_arg = arg;
+    getcontext(&gctx->uctx);
+    gctx->uctx.uc_stack.ss_sp = stack;
+    gctx->uctx.uc_stack.ss_size = (size_t)stack_size;
+    gctx->uctx.uc_link = NULL;
+    makecontext(&gctx->uctx, (void (*)())goroutines__context_trampoline, 0);
+}
+
+static void goroutines_context_switch(void *from_buf, void *to_buf) {
+    goroutine_ctx_t *from = (goroutine_ctx_t *)from_buf;
+    goroutine_ctx_t *to = (goroutine_ctx_t *)to_buf;
+    // If switching to a goroutine that hasn't started yet, set TLS for trampoline
+    if (to->entry_fn != NULL) {
+        _goroutine_start_ctx = to;
+    }
+    swapcontext(&from->uctx, &to->uctx);
+}
+
+static void goroutines_context_set(void *to_buf) {
+    goroutine_ctx_t *to = (goroutine_ctx_t *)to_buf;
+    if (to->entry_fn != NULL) {
+        _goroutine_start_ctx = to;
+    }
+    setcontext(&to->uctx);
+}
+
+#endif

vlib/io/readerwriter.v

@@ -17,7 +17,8 @@ mut:
 // read reads up to `buf.len` bytes into `buf`. It returns
 // the number of bytes read or any error encountered.
 pub fn (mut r ReaderWriterImpl) read(mut buf []u8) !int {
-	return r.r.read(mut buf)
+	mut local_buf := unsafe { buf[0..buf.len] }
+	return r.r.read(mut local_buf)
 }
 
 // write writes `buf.len` bytes from `buf` to the underlying