v3: keep fastc AST-free

Author: medvednikov

cmd/v/macos_v3_args.c.v

@@ -44,8 +44,8 @@ fn is_macos_v3_compiler_bootstrap(normalized_path string) bool {
 // invocation to the embedded V3 compiler. It gates on `-old-compiler`
 // 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
-// complete lane uses V3's checked frontend and full fastc generator for the compiler source.
+// targets normally stay on V1, but explicit `-b fastc` still routes to V3 so its
+// AST-free parser can report unsupported source instead of silently selecting V1.
 // 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.
@@ -59,7 +59,7 @@ fn macos_v3_force_requested(command string, prefs &pref.Preferences) bool {
 	}
 	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.
+		// Explicit FastC stays on V3 and reports this mode as unsupported.
 		return false
 	}
 	if prefs.path == '' || command == 'test' || macos_v3_non_compilation_command(command)
@@ -99,8 +99,8 @@ fn macos_v3_fastc_incompatibility(prefs &pref.Preferences) ?string {
 // 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.
+// memory than the test itself. Explicit FastC is never diverted to an AST-based
+// ownership compiler; its parser reports the unsupported mode itself.
 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)

cmd/v/macos_v3_darwin.c.v

@@ -91,7 +91,7 @@ fn is_macos_v3_relevant_command(command string, prefs &pref.Preferences) bool {
 	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.
+		// Explicit FastC stays on V3 and reports this mode as unsupported.
 		return false
 	}
 	if command == 'test' {

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 prefs.is_fastc {
+		// FastC owns its whole invocation and must never launch the AST-based
+		// ownership compiler. Its direct parser reports unsupported modes.
+		return
+	}
 	$if macos {
 		if macos_v3_test_ownership_uses_v1(prefs, merged_args) {
 			return

vlib/v/help/build/build.txt

@@ -43,7 +43,7 @@ NB: the build flags are shared with the run command too:
     Specifies the backend that will be used for building the executable.
     Current list of supported backends:
     * `c` (default)       - V outputs C source code, which is then passed to a C compiler.
-    * `fastc`             - V outputs C with the experimental FastC backend.
+    * `fastc`             - V parses supported source directly to C without an AST.
     * `go`                - V outputs Go source code, which is then passed to a Go compiler.
     * `js`                - V outputs JS source code which can be passed to NodeJS to be ran.
     * `js_browser`        - V outputs JS source code ready for the browser.

vlib/v3/README.md

@@ -90,46 +90,32 @@ physical footprint immediately after RSS.
 
 ## Fast C backend
 
-`-b fastc` selects the embedded V3 driver and a speculative single-file backend for the shortest
-edit-run cycle. It scans the source once and emits GNU C while consuming tokens. This path does
-not create a flat AST itself. Before accepting its speculative output, the driver runs the normal
-parser and semantic checker over the V source, then asks bundled TinyCC to validate the complete
-translation unit. A successful direct build skips transform, type annotation, and mark-used.
-
-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.
-
-Integer-range bounds in the direct lane are evaluated once, from left to right. Float printing,
-C-string and embedded-NUL string literals, assertions, `sizeof`, comparison/logical, shift,
-division, and modulo expressions, and functions with narrow integer signatures are promoted to
-the complete lane. Expressions containing decimal `2147483648`, including composite minimum-`int`
-expressions, are promoted as well, as are hexadecimal and binary literals above the signed 32-bit
-range. Parallel assignments and indexing expressions are promoted, preserving
-simultaneous assignment, V layouts, inferred types, element types, and bounds checks. Together these
-promotions preserve V's formatting, byte-length, diagnostics, boolean typing, integer-wrapping,
-safe-shift, and zero-divisor behavior instead of relying on incompatible raw C semantics.
-
-The direct path is limited to host-target, non-debug, non-production, non-test, non-shared
-single-file builds. Compiler/self-host, strict C, 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. Direct C-only output is published
-only after both V semantic checking and TinyCC validation succeed.
-
-`v self -b fastc` and direct compiler builds such as `v -b fastc -o v2 cmd/v` are routed to V3.
-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.
+`-b fastc` selects the embedded V3 driver and its AST-free single-file parser for the shortest
+edit-run cycle. FastC scans the source once and emits GNU C while consuming tokens. It never invokes
+the flat parser, semantic checker, transformer, mark-used pass, or conventional C generator.
+Bundled TinyCC validates the emitted translation unit before any C file or executable is published.
+Unsupported V syntax and TinyCC errors are reported directly; FastC never retries through an
+AST-based backend.
+
+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. Integer-range bounds are
+evaluated once, from left to right. The parser also rejects mutation of immutable or unknown local
+names instead of relying on C's weaker assignment rules.
+
+Syntax whose V semantics require type or runtime information is rejected until FastC can lower it
+directly. This includes float printing, C-string and embedded-NUL string literals, runes,
+assertions, `sizeof`, comparison/logical, shift, division, modulo, indexing, parallel assignment,
+mixed-precedence expressions, narrow integer signatures, oversized decimal literals, and
+high-bit hexadecimal or binary literals. Rejecting these constructs avoids silently applying
+incompatible C formatting, inference, wrapping, shift, bounds, and zero-divisor behavior.
+
+FastC requires exactly one `.v` input. Executables are host-target only; `-o file.c` also permits an
+explicit cross target and publishes C after TinyCC validation. Production, test, shared/live,
+ownership/autofree, self-host, object-file, profiling/coverage, strict C, custom compiler,
+custom-builtin, `no_main`, translated, and REPL modes are currently rejected. Explicit FastC
+compiler builds still route to V3 so the FastC parser reports the unsupported input rather than
+silently selecting V1.
 
 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
@@ -212,8 +198,7 @@ the plan and run the complete diagnostic and generation pipeline normally.
 ## Architecture
 
 ```
-source -> fastc scanner/emitter -> TinyCC
-     \-> on unsupported syntax or TinyCC error: normal pipeline below
+source -> scanner -> fastc parser/C emitter -> TinyCC
 
 source + vlib/builtin -> scanner -> flat parser -> flat AST -> imports
   -> check -> transform -> annotate types -> markused -> gen C -> cc