v3: add full fastc backend

Author: medvednikov

cmd/v/macos_v3_args.c.v

@@ -24,7 +24,7 @@ fn macos_v3_non_compilation_command(command string) bool {
 // precedence, options/modes V3 cannot honor yet, and whether the command is an
 // actual compilation command (never `test` or external tools). Compiler bootstrap
 // targets normally stay on V1, but explicit `-b fastc` owns those targets too: its
-// direct emitter falls back to V3's checked C backend for the full compiler source.
+// complete lane uses V3's checked frontend and full fastc generator for the compiler source.
 // Both the Darwin dispatcher (where it overrides the default heuristic) and the
 // non-macOS dispatcher (where it is the sole gate) rely on it, so it must stay
 // platform neutral.
@@ -36,7 +36,9 @@ fn macos_v3_force_requested(command string, prefs &pref.Preferences) bool {
 	if v3_has_v1_only_preferences(prefs) || (prefs.gc_set_by_flag && prefs.gc_mode != .no_gc) {
 		return false
 	}
-	if prefs.autofree && prefs.is_run {
+	if prefs.autofree && prefs.is_run && !macos_v3_fastc_requested(prefs) {
+		// V1 still owns the established `v -autofree run ...` orchestration.
+		// FastC promotes autofree programs to its checked C lane.
 		return false
 	}
 	if prefs.path == '' || command == 'test' || macos_v3_non_compilation_command(command)
@@ -65,6 +67,16 @@ fn macos_v3_fastc_requested(prefs &pref.Preferences) bool {
 	return selected_backend == 'fastc'
 }
 
+// macos_v3_test_ownership_uses_v1 keeps ownership/autofree test binaries on
+// V1. vtest marks its per-file compilations with `-skip-running`; compiling an
+// autofree test through the ownership-enabled V3 tool can consume far more
+// memory than the test itself. Direct V3 ownership builds remain available;
+// fastc uses the same checked ownership lane as the C backend.
+fn macos_v3_test_ownership_uses_v1(prefs &pref.Preferences, args []string) bool {
+	return prefs.skip_running && !macos_v3_fastc_requested(prefs)
+		&& (prefs.autofree || '-ownership' in args)
+}
+
 // These helpers are shared by the native Darwin dispatcher and the default
 // implementation selected while generating cross-platform VC sources, so this
 // file has to stay platform neutral (no `_darwin.c.v` suffix). Keep them outside

cmd/v/macos_v3_darwin.c.v

@@ -39,6 +39,10 @@ fn maybe_delegate_to_macos_v3(command string, prefs &pref.Preferences) ?MacosV3C
 	}
 	all_args := util.join_env_vflags_and_os_args()
 	forwarded_args := all_args[1..]
+	if macos_v3_test_ownership_uses_v1(prefs, forwarded_args) {
+		trace_macos_v3_skip('vtest ownership/autofree compilation')
+		return take_macos_v3_c_error_report()
+	}
 	if !macos_v3_executable_can_dispatch(os.executable(), prefs) {
 		trace_macos_v3_skip('non-default compiler executable `${os.executable()}`')
 		return none
@@ -80,9 +84,10 @@ fn is_macos_v3_relevant_command(command string, prefs &pref.Preferences) bool {
 		// dispatch, but it must not prevent V3 from being the default compiler.
 		return false
 	}
-	if prefs.autofree && prefs.is_run {
+	if prefs.autofree && prefs.is_run && !macos_v3_fastc_requested(prefs) {
 		// V1 still owns the established `v -autofree run ...` orchestration.
 		// Direct autofree builds are selected earlier by the ownership dispatcher.
+		// FastC promotes autofree programs to its checked C lane.
 		return false
 	}
 	if command == 'test' {

cmd/v/macos_v3_test.v

@@ -1711,4 +1711,24 @@ fn test_macos_v3_fastc_routes_compiler_selfhost_targets() {
 	assert !macos_v3_fastc_requested(&pref.Preferences{
 		build_options: ['-b fastc', '-b c']
 	})
+	assert macos_v3_force_requested('run', &pref.Preferences{
+		new_compiler:  true
+		autofree:      true
+		is_run:        true
+		path:          'main.v'
+		build_options: ['-b fastc']
+	})
+}
+
+fn test_macos_v3_vtest_ownership_modes_use_v1_except_fastc() {
+	mut prefs := &pref.Preferences{
+		skip_running: true
+		autofree:     true
+	}
+	assert macos_v3_test_ownership_uses_v1(prefs, ['-skip-running', '-autofree', 'main.v'])
+	prefs.autofree = false
+	assert macos_v3_test_ownership_uses_v1(prefs, ['-skip-running', '-ownership', 'main.v'])
+	prefs.build_options = ['-b fastc']
+	assert !macos_v3_test_ownership_uses_v1(prefs, ['-skip-running', '-ownership', '-b',
+		'fastc', 'main.v'])
 }

cmd/v/v.v

@@ -219,6 +219,11 @@ fn invoke_help_and_exit(remaining []string) {
 fn maybe_delegate_to_ownership(command string, prefs &pref.Preferences, merged_args []string) {
 	is_ownership := '-ownership' in merged_args
 	is_autofree := prefs.autofree
+	$if macos {
+		if macos_v3_test_ownership_uses_v1(prefs, merged_args) {
+			return
+		}
+	}
 	if !ownership_delegation_is_requested(is_ownership, is_autofree, prefs.old_compiler,
 		os.user_os()) {
 		return

vlib/v3/README.md

@@ -95,24 +95,28 @@ edit-run cycle. It scans the source once and emits GNU C while consuming tokens.
 not create a flat AST and does not run imports, type checking, transform, type annotation, or
 mark-used. Bundled TinyCC compiles the emitted translation unit immediately.
 
-FastC currently emits primitive functions and parameters, inferred local declarations, ordinary
-expressions, `if`/`else`, and condition, C-style, infinite, and integer-range `for` loops. GNU
-`typeof` carries `:=` declarations into C without V type inference. Unsupported syntax silently
-selects the normal C backend. A TinyCC error is also discarded and the original V source is
-reparsed by the normal C backend, so the user receives V parser or type-checker diagnostics rather
-than a speculative C diagnostic. A successfully compiled `run` program keeps its exit status and
-is never retried.
+FastC's direct lane currently emits primitive functions and parameters, inferred local
+declarations, ordinary expressions, `if`/`else`, and condition, C-style, infinite, and
+integer-range `for` loops. GNU
+`typeof` carries `:=` declarations into C without V type inference. Unsupported syntax promotes
+the source to fastc's complete lane, which uses the parser, checker, transformer, and mark-used
+pass, then emits C with its own `v3.gen.fastc.FlatGen` backend. That backend is a full fork of the
+V3 C generator rather than an alias or a runtime switch to `v3.gen.c`. A TinyCC error is also
+discarded and the original V source is compiled by the checked fastc lane, so the user receives V
+parser or type-checker diagnostics rather than a speculative C diagnostic. The complete lane has
+the same language and ownership/autofree coverage as the C backend. A successfully compiled `run`
+program keeps its exit status and is never retried.
 
 The direct path is limited to host-target, non-production, non-test, non-shared single-file builds.
-Other modes select the normal C backend before source scanning. `-o file.c` emits the standalone
-fast C translation unit without invoking TinyCC.
+Compiler/self-host and other non-direct modes enter the complete lane before source scanning.
+`-o file.c` emits the standalone fast C translation unit when the direct lane supports the input;
+otherwise it emits the complete `v3.gen.fastc` translation unit.
 
 `v self -b fastc` and direct compiler builds such as `v -b fastc -o v2 cmd/v` are routed to V3.
-The compiler source is outside the direct subset, so fastc immediately selects the checked V3 C
-backend for that build. The resulting self-hosted compiler retains fastc and can use the direct
-path for supported user programs, including when its output has a custom filename in the V checkout.
-The fastc integration test self-hosts the standalone V3 compiler through five successive generations
-and verifies that the fifth generation still compiles and runs a direct-fastc program.
+Self-host builds enter fastc's complete lane directly. The checked frontend feeds the independent
+`v3.gen.fastc.FlatGen` implementation, so the resulting compiler supports the full V3 source tree
+and retains both fastc lanes for user programs, including when its output has a custom filename in
+the V checkout. The fastc integration test exercises five successive self-host generations.
 
 Generated C represents `thread` values with a typed wrapper around `pthread_t`. `spawn` and
 detached standard-library workers use the target's default thread stack (8 MiB on 64-bit targets