parser: add error for typeof(T), suggesting typeof[T]() instead

These changes almost do not speed up the program with the `-prod` flag,
since modern С compilers can do such optimization on their own, but in
normal mode, the performance gain is from 1.6 (concatenation) to 1.8 (repeat) times.

Concatenation:
Old (`for` loop):
Time (mean):          3.699 s +- 0.071 s  [User: 3.629 s, System: 0.069 s]
Range (min ... max):  3.548 s ... 3.741 s  10 runs

New (vmemcpy):
Time (mean):          2.305 s +- 0.065 s  [User: 2.263 s, System: 0.041 s]
Range (min ... max):  2.172 s ... 2.355 s  10 runs

`vmemcpy version` ran 1.60 +- 0.05 times faster than 'for loop version'

.cirrus.yml

@@ -3,6 +3,7 @@ freebsd_instance:
 
 freebsd_task:
   name: Code CI / freebsd
+  skip: "!changesInclude('.cirrus.yml', '**.{v,vsh}')"
   install_script: pkg install -y git
   script: |
     echo 'Building V'
@@ -13,76 +14,6 @@ freebsd_task:
     ##tcc -v -v
     echo 'Build cmd/tools/fast'
     cd cmd/tools/fast && ../../../v fast.v && ./fast -clang
-
-
-arm64_task:
-  name: Code CI / arm64-ubuntu-tcc
-  arm_container:
-    image: ubuntu:latest
-  install_script: apt-get update -y && apt-get install --quiet -y build-essential pkg-config wget git valgrind libsqlite3-dev libssl-dev libxi-dev libxcursor-dev libfreetype6-dev libxi-dev libxcursor-dev libgl-dev xfonts-75dpi xfonts-base libmysqlclient-dev libpq-dev gcc-10-arm-linux-gnueabihf libc6-dev-armhf-cross qemu-user
-  env:
-    DEBIAN_FRONTEND: noninteractive
-    VFLAGS: -cc tcc -no-retry-compilation
-    VJOBS: 2
-  script: |
-    set -e
-
-    wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_arm64.deb
-    apt install --fix-missing -y ./wkhtmltox_0.12.6-1.focal_arm64.deb
-
-    # ensure that a V binary can be built, even if tcc has broken for some reason
-    VFLAGS='-cc gcc' make
-
-    ./v -g self
-    ./v -g self
-
-    ./v -d debug_malloc -d debug_realloc -o v cmd/v
-    ./v -cg -cstrict -o v cmd/v
-    #Test v->c
-    thirdparty/tcc/tcc.exe -version
-    ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
-
-    # - name: v self compilation
-    ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
-
-    # - name: v self compilation with -skip-unused
-    ./v -skip-unused -o v2 cmd/v && ./v2 -skip-unused -o v3 cmd/v && ./v3 -skip-unused -o v4 cmd/v
-
-    # - name: v doctor
-    ./v doctor
-
-    # - name: Verify `v test` works
-    ./v cmd/tools/test_if_v_test_system_works.v
-    ./cmd/tools/test_if_v_test_system_works
-
-    # - name: Self tests
-    ./v -silent test-self
-
-    ## - name: Self tests (-cstrict)
-    ## ./v -cstrict test-self
-
-    # - name: Test time functions in a timezone UTC-12
-    TZ=Etc/GMT+12 ./v test vlib/time/
-    # - name: Test time functions in a timezone UTC-3
-    TZ=Etc/GMT+3 ./v test vlib/time/
-    # - name: Test time functions in a timezone UTC+3
-    TZ=Etc/GMT-3 ./v test vlib/time/
-    # - name: Test time functions in a timezone UTC+12
-    TZ=Etc/GMT-12 ./v test vlib/time/
-    # - name: Test time functions in a timezone using daylight saving (Europe/Paris)
-    TZ=Europe/Paris ./v test vlib/time/
-    # - name: Build examples
-    ./v -W build-examples
-    # - name: Test building v tools
-    ./v -W build-tools
-    # - name: Test v binaries
-    ./v build-vbinaries
-    # - name: Run a VSH script
-    ./v run examples/v_script.vsh
-    # - name: Test v tutorials
-    ./v tutorials/building_a_simple_web_blog_with_vweb/code/blog
-
-    # test the arm32 version of tcc
-    # TODO: support something like `V_EMULATOR=qemu-arm v run file.v` so that V automatically runs all binaries under qemu
-    ./v -arch arm32 -cc arm-linux-gnueabihf-gcc-10 -o av cmd/v && qemu-arm -L /usr/arm-linux-gnueabihf ./av -arch arm32 -cc arm-linux-gnueabihf-gcc-10 -o av2 cmd/v && qemu-arm -L /usr/arm-linux-gnueabihf ./av2 -arch arm32 -cc arm-linux-gnueabihf-gcc-10 -o av3 cmd/v && qemu-arm -L /usr/arm-linux-gnueabihf ./av3 -arch arm32 -cc arm-linux-gnueabihf-gcc-10 -o av4 cmd/v
-    ./v -arch arm32 -o closure_test.c vlib/v/tests/closure_test.v && arm-linux-gnueabihf-gcc-10 -o closure_test closure_test.c && qemu-arm -L /usr/arm-linux-gnueabihf ./closure_test
+    echo 'Run test-self'
+    cd /tmp/cirrus-ci-build/v
+    VTEST_JUST_ESSENTIAL=1 ./v test-self

.editorconfig

@@ -8,7 +8,10 @@ trim_trailing_whitespace = true
 
 [*.v]
 indent_style = tab
-indent_size = 4
+
+[*.{bat,cmd}]
+# BAT/CMD ~ DOS/Win requires BAT/CMD files to have CRLF EOLNs
+end_of_line = crlf
 
 [*.{yml,yaml}]
 indent_style = space

.gitattributes

@@ -1,5 +1,7 @@
 *.v linguist-language=V text=auto eol=lf
 *.vv linguist-language=V text=auto eol=lf
+*.vsh linguist-language=V text=auto eol=lf
+**/v.mod linguist-language=V text=auto eol=lf
 *.bat text=auto eol=crlf
  Dockerfile.* linguist-language=Dockerfile
 *.toml text eol=lf

.github/ISSUE_TEMPLATE/bug-report-for-v.md

@@ -1,25 +0,0 @@
----
-name: Bug report for V
-about: Please use the appropriate label when submitting an issue: bug/feature request/question.
-title: "New issue"
-labels: ''
-assignees: ''
-
----
-
-<!-- You can use `v doctor` to fill up the next fields -->
-
-#### V version:
-
-#### OS:
-
-#### C Compiler:
-
-
-## What did you do?
-
-
-### What did you expect to see?
-
-
-### What did you see instead?

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,82 @@
+name: 🐛 Bug Report
+description: Report a bug
+title: (bug report summary)
+labels: Bug
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: What is the problem? A clear and concise description of the bug.
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected Behavior
+      description: What did you expect to happen?
+    validations:
+      required: true
+
+  - type: textarea
+    id: current
+    attributes:
+      label: Current Behavior
+      description: |
+        What actually happened?
+
+        Please include full errors, uncaught exceptions, stack traces, and relevant logs.
+        If service/functions responses are relevant, please include wire logs.
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: Reproduction Steps
+      description: |
+        Provide a self-contained, concise snippet of code that can be used to reproduce the issue.
+        For more complex issues provide a repo with the smallest sample that reproduces the bug.
+
+        Avoid including business logic or unrelated code, it makes diagnosis more difficult.
+        The code sample should be an SSCCE. See http://sscce.org/ for details.
+        In short, please provide a code sample that we can copy/paste, run and reproduce.
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Possible Solution
+      description: Suggest a fix/reason for the bug
+    validations:
+      required: false
+
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional Information/Context
+      description: |
+        Anything else that might be relevant for troubleshooting this bug.
+        Providing context helps us come up with a solution that is most useful in the real world.
+    validations:
+      required: false
+
+  - type: input
+    id: version
+    attributes:
+      label: V version
+      description: |
+        Please make sure to run `v up` before reporting any issues as it may have already been fixed.
+        It's also advisable to update all relevant modules using `v outdated` and `v install`.
+    validations:
+      required: true
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: Environment details (OS name and version, etc.)
+      description: You can use `v doctor` to fill up this section.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,23 +0,0 @@
----
-name: Bug report
-about: Bug report
-title: ''
-labels: 'Bug'
-assignees: ''
-# When updating, make sure to update the template in 'cmd/tools/vbug.v' too
----
-
-<!-- Please make sure to run `v up` before reporting any issues as it may have already been fixed.
-     It's also advisable to update all relevant modules using `v outdated` and `v install` -->
-
-<!-- You can use `v doctor` to fill up the next fields -->
-**V version:** 
-**OS:** 
-
-**What did you do?**
-
-
-**What did you expect to see?**
-
- 
-**What did you see instead?**

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,9 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💬 General Questions and Answers about V
+    url: https://github.com/vlang/v/discussions/categories/questions-and-answers
+    about: You can ask and answer questions about V in the discussions forum.
+
+  - name: 💬 Discord Server
+    url: https://discord.gg/vlang
+    about: You can join our Discord server for real time discussion and support

.github/ISSUE_TEMPLATE/documentation.yml

@@ -0,0 +1,20 @@
+name: 📕 Documentation Issue
+description: Report an issue in the Reference documentation or Developer Guide
+title: (short issue description)
+labels: "Unit: Documentation"
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the issue
+      description: A clear and concise description of the issue.
+    validations:
+      required: true
+
+  - type: textarea
+    id: links
+    attributes:
+      label: Links
+      description: Include links to affected documentation page(s).
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,64 @@
+name: 🚀 Feature Request
+description: Suggest an idea for this project
+title: (feature request summary)
+labels: Feature Request
+body:
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the feature
+      description: A clear and concise description of the feature you are proposing.
+    validations:
+      required: true
+
+  - type: textarea
+    id: use-case
+    attributes:
+      label: Use Case
+      description: |
+        Why do you need this feature? For example: "I'm always frustrated when..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Proposed Solution
+      description: Suggest how to implement the addition or change. Please include prototype/workaround/sketch/reference implementation.
+    validations:
+      required: false
+
+  - type: textarea
+    id: other
+    attributes:
+      label: Other Information
+      description: Any alternative solutions or features you considered, a more detailed explanation, stack traces, related issues, links for context, etc.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: ack
+    attributes:
+      label: Acknowledgements
+      options:
+        - label: I may be able to implement this feature request
+          required: false
+
+        - label: This feature might incur a breaking change
+          required: false
+
+  - type: input
+    id: version
+    attributes:
+      label: Version used
+      description: Please provide the version of the repository or tool you are using.
+    validations:
+      required: true
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: Environment details (OS name and version, etc.)
+      description: You can use `v doctor` to fill up this section.
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,10 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: 'Feature Request'
-assignees: ''
-
----
-
-

.github/PULL_REQUEST_TEMPLATE

@@ -2,7 +2,7 @@
 
 <!--
 
-Please title your PR as follows: `time: fix foo bar`.
+Please title your PR as follows: `module: description` (e.g. `time: fix date format`).
 Always start with the thing you are fixing, then describe the fix.
 Don't use past tense (e.g. "fixed foo bar").
 
@@ -33,3 +33,17 @@ Applying labels to PRs is not needed.
 Thanks a lot for your contribution!
 
 -->
+
+<!--
+
+ATTENTION! ⚠️
+
+The below commands will be replaced with Copilot AI generated PR description.
+This description will be automatically updated to describe the latest commit of this PR.
+If you decided to remove them - please, provide a detailed description of your changes.
+
+-->
+
+copilot:summary
+
+copilot:walkthrough

.github/workflows/alpine.test.sh

@@ -15,6 +15,8 @@ ls -lat
 ## try running the known failing tests first to get faster feedback
 ./v test vlib/builtin/string_test.v vlib/strings/builder_test.v
 
+./v test-cleancode
+
 ./v test-self
 
 ./v build-vbinaries

.github/workflows/android_cross_compile.vsh

@@ -0,0 +1,67 @@
+#!/usr/bin/env -S v
+
+module main
+
+import os
+import vab.vxt
+import vab.android.ndk
+
+fn main() {
+	assert ndk.found()
+	assert vxt.found()
+
+	work_dir := os.join_path(os.vtmp_dir(), 'android_cross_compile_test')
+	os.rm(work_dir) or {}
+	os.mkdir_all(work_dir) or { panic(err) }
+	vexe := vxt.vexe()
+
+	examples_dir := os.join_path(vxt.home(), 'examples')
+	v_example := os.join_path(examples_dir, 'toml.v')
+
+	ndk_version := ndk.default_version()
+
+	sysroot_path := ndk.sysroot_path(ndk_version) or { panic(err) }
+	include_path := os.join_path(sysroot_path, 'usr', 'include')
+	android_include_path := os.join_path(include_path, 'android')
+
+	//'-I"$include_path"'
+	cflags := ['-I"$android_include_path"', '-Wno-unused-value', '-Wno-implicit-function-declaration',
+		'-Wno-int-conversion']
+	for arch in ndk.supported_archs {
+		for level in ['min', 'max'] {
+			compiler_api := match level {
+				'min' {
+					ndk.compiler_min_api(.c, ndk_version, arch) or { panic(err) }
+				}
+				'max' {
+					ndk.compiler_max_api(.c, ndk_version, arch) or { panic(err) }
+				}
+				else {
+					panic('invalid min/max level')
+				}
+			}
+
+			os.setenv('VCROSS_COMPILER_NAME', compiler_api, true)
+			c_file := os.join_path(work_dir, arch + '-' + level + '.c')
+			o_file := os.join_path(work_dir, arch + '-' + level + '.o')
+
+			// x.v -> x.c
+			v_compile_cmd := '$vexe -o $c_file -os android -gc none $v_example'
+			vres := os.execute(v_compile_cmd)
+			if vres.exit_code != 0 {
+				panic('"$v_compile_cmd" failed: $vres.output')
+			}
+			assert os.exists(c_file)
+
+			// x.c -> x.o
+			compile_cmd := '$compiler_api ${cflags.join(' ')} -c $c_file -o $o_file'
+			cres := os.execute(compile_cmd)
+			if cres.exit_code != 0 {
+				panic('"$compile_cmd" failed: $cres.output')
+			}
+			assert os.exists(o_file)
+			compiler_exe_name := os.file_name(compiler_api)
+			println('Compiled examples/toml.v successfully for ($level) $arch $compiler_exe_name')
+		}
+	}
+}

.github/workflows/bootstrapping_works_ci.yml

@@ -1,23 +1,20 @@
 name: Bootstraping works
 
 on:
-  push:
-    paths-ignore:
-      - "**.md"
-  pull_request:
-    paths-ignore:
-      - "**.md"
+  schedule:
+    - cron: '0 */6 * * *'
 
 jobs:
   ubuntu:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 15
+    runs-on: ubuntu-latest
+    if: github.event.ref == 'refs/heads/master' && github.event.repository.full_name == 'vlang/v'
+    timeout-minutes: 30
     env:
       VFLAGS: -cc tcc -no-retry-compilation
-      B_CFLAGS: -g -std=gnu11 -I ./thirdparty/stdatomic/nix -w
+      B_CFLAGS: -g -std=c99 -w
       B_LFLAGS: -lm -lpthread
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 10
       - name: Build v
@@ -48,14 +45,15 @@ jobs:
           ./v2 -o v3 cmd/v
 
   macos:
-    runs-on: macos-11
-    timeout-minutes: 15
+    runs-on: macos-latest
+    if: github.event.ref == 'refs/heads/master' && github.event.repository.full_name == 'vlang/v'
+    timeout-minutes: 30
     env:
       VFLAGS: -cc clang
-      B_CFLAGS: -g -std=gnu11 -I ./thirdparty/stdatomic/nix -w
+      B_CFLAGS: -g -std=c99 -w
       B_LFLAGS: -lm -lpthread
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 10
       - name: Build V

.github/workflows/c2v_ci.yml

@@ -0,0 +1,133 @@
+name: C2V apps
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+      - "doc/**"
+      - "examples/**"
+      - "tutorials/**"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+      - "doc/**"
+      - "examples/**"
+      - "tutorials/**"
+
+concurrency:
+  group: build-c2v-apps-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  doom-compiles:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build V
+        run: make && ./v symlink -githubci
+
+      - name: Build C2V
+        run: |
+          echo "Clone C2V"
+          mkdir -p ~/code/
+          git clone --depth 1 https://github.com/vlang/c2v ~/code/c2v
+          ln -s ~/code/c2v ~/.vmodules/c2v
+          v -g ~/.vmodules/c2v/
+          ~/.vmodules/c2v/c2v || true
+
+      - name: Install Doom Dependencies
+        run: |
+          sudo apt-get update -y -qq
+          sudo apt-get install libsdl2-dev libsdl2-mixer-dev libsdl2-net-dev libpng-dev libsamplerate0-dev
+
+      - name: Build original Chocolate Doom
+        run: |
+          git clone --quiet --depth 1 https://github.com/vlang/doom ~/code/doom
+          cd ~/code/doom/chocolate-doom
+          cmake -DCMAKE_BUILD_TYPE=Debug .
+          make chocolate-doom
+
+      - name: Translate the whole game in project/folder mode and compile it
+        run: |
+          cd ~/code/doom
+          touch ~/DOOM1.WAD
+          WAD_FILE=~/DOOM1.WAD ~/code/doom/build_whole_project.sh
+
+  doom-regressions:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 10
+    env:
+      VFLAGS: -cc tcc
+      DISPLAY: :99
+      LIBGL_ALWAYS_SOFTWARE: true
+      VTMP: /tmp
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build V
+        run: make && ./v symlink -githubci
+
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update -y -qq
+
+          # c2v / DOOM dependencies
+          sudo apt-get install libsdl2-dev libsdl2-mixer-dev libsdl2-net-dev libpng-dev libsamplerate0-dev
+
+          # vgret dependencies
+          # imagemagick              : convert, mogrify, import
+          # xvfb                     : For starting X11 Virtual FrameBuffers
+          # openimageio-tools        : idiff
+          # libgl1-mesa-dri          : For headless rendering / software DRI driver (LIBGL_ALWAYS_SOFTWARE=true)
+          # freeglut3-dev            : Fixes graphic apps compilation with tcc
+          sudo apt-get install imagemagick openimageio-tools freeglut3-dev libgl1-mesa-dri xvfb xsel xclip
+
+          # Fetch the free ~4MB DOOM1.WAD from the link at https://doomwiki.org/wiki/DOOM1.WAD
+          wget https://distro.ibiblio.org/slitaz/sources/packages/d/doom1.wad -O ~/doom1.wad
+
+          # Get imgur upload script
+          wget https://raw.githubusercontent.com/tremby/imgur.sh/c98345d/imgur.sh
+          chmod +x ./imgur.sh
+
+          # Get regression images to test against
+          git clone https://github.com/Larpon/doom-regression-images
+
+      - name: Build C2V
+        run: |
+          echo "Clone C2V"
+          mkdir -p ~/code/
+          git clone --depth 1 https://github.com/vlang/c2v ~/code/c2v
+          ln -s ~/code/c2v ~/.vmodules/c2v
+          v -g ~/.vmodules/c2v/
+          ~/.vmodules/c2v/c2v || true
+
+      - name: Build original Chocolate Doom
+        run: |
+          git clone --quiet --depth 1 https://github.com/vlang/doom ~/code/doom
+          cd ~/code/doom/chocolate-doom
+          cmake -DCMAKE_BUILD_TYPE=Debug .
+          make chocolate-doom
+
+      - name: Translate the whole game in project/folder mode
+        run: |
+          cd ~/code/doom
+          WAD_FILE=~/doom1.wad ~/code/doom/build_whole_project.sh
+
+      - name: Sample and compare with vgret
+        id: compare
+        continue-on-error: true
+        run: |
+          Xvfb $DISPLAY -screen 0 800x600x24 -fbdir /var/tmp/ &
+          sleep 1; while [ ! -f /var/tmp/Xvfb_screen0 ]; do sleep 0.5; done # give xvfb time to start, even on slow CI runs
+          v gret -r ~/code/doom -t ./doom-regression-images/vgret.doom.toml -v ./doom-sample_images ./doom-regression-images
+
+      - name: Upload regression to imgur
+        if: steps.compare.outcome != 'success'
+        run: |
+          ./imgur.sh /tmp/fail.png
+          ./imgur.sh /tmp/diff.png
+          exit 1

.github/workflows/ci.yml

@@ -1,694 +0,0 @@
-name: Code CI
-
-on:
-  push:
-    paths-ignore:
-      - "**.md"
-  pull_request:
-    paths-ignore:
-      - "**.md"
-
-concurrency:
-  group: build-ci-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-jobs:
-  ubuntu-tcc:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc tcc -no-retry-compilation
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-          ## The following is needed for examples/wkhtmltopdf.v
-          wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_amd64.deb
-          sudo apt-get install --quiet -y xfonts-75dpi xfonts-base
-          sudo dpkg -i wkhtmltox_0.12.6-1.focal_amd64.deb
-      - name: Build v
-        run: |
-          echo $VFLAGS
-          make
-          ./v -d debug_malloc -d debug_realloc -o v cmd/v
-          ./v -cg -cstrict -o v cmd/v
-          # Test v -realloc arena allocation
-          ./v -o vrealloc -prealloc cmd/v && ./vrealloc -o v3 cmd/v && ./v3 -o v4 cmd/v
-      - name: Test v->c
-        run: |
-          thirdparty/tcc/tcc.exe -version
-          ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
-      #        ./v -silent test-all
-      - name: v self compilation
-        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
-      - name: v self compilation with -skip-unused
-        run: ./v -skip-unused -o v2 cmd/v && ./v2 -skip-unused -o v3 cmd/v && ./v3 -skip-unused -o v4 cmd/v
-      - name: v doctor
-        run: |
-          ./v doctor
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests
-        run: ./v -silent test-self
-      # - name: Self tests (-cstrict)
-      #   run: ./v -cstrict test-self
-      - name: Test time functions in a timezone UTC-12
-        run: TZ=Etc/GMT+12 ./v test vlib/time/
-      - name: Test time functions in a timezone UTC-3
-        run: TZ=Etc/GMT+3 ./v test vlib/time/
-      - name: Test time functions in a timezone UTC+3
-        run: TZ=Etc/GMT-3 ./v test vlib/time/
-      - name: Test time functions in a timezone UTC+12
-        run: TZ=Etc/GMT-12 ./v test vlib/time/
-      - name: Test time functions in a timezone using daylight saving (Europe/Paris)
-        run: TZ=Europe/Paris ./v test vlib/time/
-      - name: Build examples
-        run: ./v -W build-examples
-      - name: Test building v tools
-        run: ./v -W build-tools
-      - name: Test v binaries
-        run: ./v build-vbinaries
-      - name: Run a VSH script
-        run: ./v run examples/v_script.vsh
-      - name: Test v tutorials
-        run: ./v tutorials/building_a_simple_web_blog_with_vweb/code/blog
-      - name: Build cmd/tools/fast
-        run: cd cmd/tools/fast && ../../../v fast.v && ./fast
-      - name: V self compilation with -usecache
-        run: |
-          unset VFLAGS
-          ./v -usecache examples/hello_world.v && examples/hello_world
-          ./v  -o v2 -usecache cmd/v
-          ./v2 -o v3 -usecache cmd/v
-          ./v3 version
-          ./v3 -o tetris  -usecache examples/tetris/tetris.v
-
-  ubuntu-tcc-boehm-gc:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc tcc -no-retry-compilation
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-          sudo apt-get install --quiet -y libgc-dev
-          ## The following is needed for examples/wkhtmltopdf.v
-          wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_amd64.deb
-          sudo apt-get install --quiet -y xfonts-75dpi xfonts-base
-          sudo dpkg -i wkhtmltox_0.12.6-1.focal_amd64.deb
-      - name: Build v
-        run: |
-          echo $VFLAGS
-          make
-      - name: Test v->c
-        run: |
-          thirdparty/tcc/tcc.exe -version
-          ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
-      - name: v self compilation with -gc boehm
-        run: |
-          ./v -gc boehm -o v2 cmd/v && ./v2 -gc boehm -o v3 cmd/v && ./v3 -gc boehm -o v4 cmd/v
-          mv v4 v
-      - name: v doctor
-        run: |
-          ./v doctor
-      - name: Verify `v -gc boehm test` works
-        run: |
-          ./v -gc boehm cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests with `-gc boehm` with V compiler using Boehm-GC itself
-        run: ./v -gc boehm -silent test-self
-      - name: Test leak detector
-        run: |
-          ./v -gc boehm_leak -o testcase_leak vlib/v/tests/testcase_leak.vv
-          ./testcase_leak 2>leaks.txt
-          grep "Found 1 leaked object" leaks.txt && grep ", sz=1000," leaks.txt
-      - name: Test leak detector not being active for `-gc boehm`
-        run: |
-          ./v -gc boehm -o testcase_leak vlib/v/tests/testcase_leak.vv
-          ./testcase_leak 2>leaks.txt
-          [ "$(stat -c %s leaks.txt)" = "0" ]
-      - name: Test leak detector not being active for normal compile
-        run: |
-          ./v -o testcase_leak vlib/v/tests/testcase_leak.vv
-          ./testcase_leak 2>leaks.txt
-          [ "$(stat -c %s leaks.txt)" = "0" ]
-
-  macos:
-    runs-on: macOS-latest
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc clang
-      PKG_CONFIG_PATH: /usr/local/opt/openssl@3/lib/pkgconfig
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Install dependencies
-        run: |
-          ##brew install libpq openssl freetype ### these are *already installed* on Catalina ...
-          brew uninstall --ignore-dependencies libpq ## libpq is a dependency of PHP
-          brew install postgresql openssl
-          export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
-          echo "PKG_CONFIG_PATH is '$PKG_CONFIG_PATH'"
-      - name: Build V
-        run: make -j4 && ./v -cg -cstrict -o v cmd/v
-      - name: Run sanitizers
-        run: |
-          ./v -o v2 cmd/v -cflags -fsanitize=undefined
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
-      - name: Build V using V
-        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v
-      - name: Test symlink
-        run: ./v symlink
-      #    - name: Set up pg database
-      #      run: |
-      #        pg_ctl -D /usr/local/var/postgres -l /usr/local/var/postgres/server.log start
-      #        psql -d postgres -c 'select rolname from pg_roles'
-      #        psql -d postgres -c 'create database customerdb;'
-      #        psql -d customerdb -f examples/database/pg/mydb.sql
-      #    - name: Test v->c
-      #      run: ./v -silent test-all
-      #    - name: Test v binaries
-      #      run: ./v build-vbinaries
-      ##    - name: Test v->js
-      ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-
-      - name: Self tests
-        run: VJOBS=1 ./v -silent test-self
-
-      - name: Build examples
-        run: ./v build-examples
-
-      - name: Build examples with -autofree
-        run: |
-          ./v -autofree -o tetris examples/tetris/tetris.v
-          ./v -autofree -o blog tutorials/building_a_simple_web_blog_with_vweb/code/blog
-      - name: v doctor
-        run: |
-          ./v doctor
-
-      - name: Test ved
-        run: |
-          git clone --depth 1 https://github.com/vlang/ved
-          cd ved && ../v -o ved .
-          ../v -autofree .
-          cd ..
-
-#      - name: Test c2v
-#        run: |
-#          git clone --depth 1 https://github.com/vlang/c2v
-#          cd c2v && ../v -o c2v .
-#          ../v .
-#          ../v run tests/run_tests.vsh
-#          ../v -experimental -w c2v_test.v
-#          cd ..
-
-      - name: Build V UI examples
-        run: |
-          git clone --depth 1 https://github.com/vlang/ui
-          cd ui
-          mkdir -p ~/.vmodules
-          ln -s $(pwd) ~/.vmodules/ui
-          ../v examples/rectangles.v
-          ## ../v run examples/build_examples.vsh
-
-  ubuntu:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-      - name: Build V
-        run: make -j4 && ./v -cc gcc -cg -cstrict -o v cmd/v
-      - name: Valgrind v.c
-        run: valgrind --error-exitcode=1 ./v -o v.c cmd/v
-      - name: Run sanitizers
-        run: |
-          ./v -o v2 cmd/v -cflags -fsanitize=thread
-          ./v -o v3 cmd/v -cflags "-fsanitize=undefined -fno-sanitize=alignment"
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v3 -o v.c cmd/v
-      #    - name: Test V
-      #      run: ./v -silent test-all
-      #    - name: Test v binaries
-      #      run: ./v build-vbinaries
-      ##    - name: Test v->js
-      ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-      #    - name: Build Vorum
-      #      run: git clone --depth 1 https://github.com/vlang/vorum && cd vorum && ../v . && cd ..
-      #    - name: Build vpm
-      #      run: git clone --depth 1 https://github.com/vlang/vpm && cd vpm && ../v . && cd ..
-      - name: Freestanding
-        run: ./v -freestanding run vlib/os/bare/bare_example_linux.v
-      - name: V self compilation
-        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
-      - name: V self compilation with -usecache
-        run: |
-          unset VFLAGS
-          ./v -usecache examples/hello_world.v && examples/hello_world
-          ./v  -o v2     -usecache cmd/v
-          ./v2 -o v3     -usecache cmd/v
-          ./v3 version
-          ./v3 -o tetris -usecache examples/tetris/tetris.v
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests
-        run: |
-          ./v -silent test-self
-      - name: Self tests (-prod)
-        run: ./v -o vprod -prod cmd/v && ./vprod -silent test-self
-      - name: Self tests (-cstrict)
-        run: ./v -cc gcc -cstrict test-self
-      - name: Build examples
-        run: ./v build-examples
-      - name: Build tetris.v with -autofree
-        run: ./v -autofree -experimental -o tetris examples/tetris/tetris.v
-      - name: Build option_test.v with -autofree
-        run: ./v -autofree vlib/v/tests/option_test.v
-      - name: Build modules
-        run: |
-          ./v build-module vlib/os
-          ./v build-module vlib/builtin
-          ./v build-module vlib/strconv
-          ./v build-module vlib/time
-          ./v build-module vlib/term
-          ./v build-module vlib/math
-          ./v build-module vlib/strings
-          ./v build-module vlib/v/token
-          ./v build-module vlib/v/ast
-          ./v build-module vlib/v/parser
-          ./v build-module vlib/v/gen/c
-          ./v build-module vlib/v/depgraph
-          ./v build-module vlib/os/cmdline
-      - name: native machine code generation
-        run: |
-          exit
-          ./v -o vprod -prod cmd/v
-          cd cmd/tools
-          echo "Generating a 1m line V file..."
-          ../../vprod gen1m.v
-          ./gen1m > 1m.v
-          echo "Building it..."
-          ../../vprod -backend native -o 1m 1m.v
-          echo "Running it..."
-          ls
-
-  #        ./1m
-  # run: echo "TODO" #cd examples/native && ../../v -native hello_world.v && ./hello_world
-  #    - name: Coveralls GitHub Action
-  #      uses: coverallsapp/github-action@v1.0.1
-  #      with:
-  #        github-token: ${{ secrets.GITHUB_TOKEN }}
-
-  ubuntu-clang:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc clang
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-          sudo apt-get install --quiet -y clang
-      - name: Build V
-        run: make -j4 && ./v -cc clang -cg -cstrict -o v cmd/v
-      - name: Valgrind
-        run: valgrind --error-exitcode=1 ./v -o v.c cmd/v
-      - name: Run sanitizers
-        run: |
-          ./v -o v2 cmd/v -cflags -fsanitize=memory
-          ./v -o v3 cmd/v -cflags -fsanitize=thread
-          ./v -o v4 cmd/v -cflags -fsanitize=undefined
-          ./v -o v5 cmd/v -cflags -fsanitize=address,pointer-compare,pointer-subtract
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v3 -o v.c cmd/v
-          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v4 -o v.c cmd/v
-          ASAN_OPTIONS=detect_leaks=0 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v5 -o v.c cmd/v
-      - name: v self compilation
-        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
-      - name: v self compilation with -usecache
-        run: |
-          unset VFLAGS
-          ./v -usecache examples/hello_world.v && examples/hello_world
-          ./v  -o v2     -usecache cmd/v
-          ./v2 -o v3     -usecache cmd/v
-          ./v3 version
-          ./v3 -o tetris -usecache examples/tetris/tetris.v
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests
-        run: |
-          ./v -silent test-self
-      - name: Self tests (-prod)
-        run: ./v -o vprod -prod cmd/v && ./vprod -silent test-self
-      - name: Self tests (-cstrict)
-        run: ./v -cstrict test-self
-      - name: Build examples
-        run: ./v build-examples
-      - name: Build examples with -autofree
-        run: |
-          ./v -autofree -experimental -o tetris examples/tetris/tetris.v
-      - name: Build modules
-        run: |
-          ./v build-module vlib/os
-          ./v build-module vlib/builtin
-          ./v build-module vlib/strconv
-          ./v build-module vlib/time
-          ./v build-module vlib/term
-          ./v build-module vlib/math
-          ./v build-module vlib/strings
-          ./v build-module vlib/v/token
-          ./v build-module vlib/v/ast
-          ./v build-module vlib/v/parser
-          ./v build-module vlib/v/gen/c
-          ./v build-module vlib/v/depgraph
-          ./v build-module vlib/os/cmdline
-      - name: native machine code generation
-        run: |
-          exit
-          ./v -o vprod -prod cmd/v
-          cd cmd/tools
-          echo "Generating a 1m line V file..."
-          ../../vprod gen1m.v
-          ./gen1m > 1m.v
-          echo "Building it..."
-          ../../vprod -backend native -o 1m 1m.v
-          echo "Running it..."
-          ls
-
-  windows-gcc:
-    runs-on: windows-2019
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc gcc
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Build
-        run: |
-          gcc --version
-          .\make.bat -gcc
-      - name: Test new v.c
-        run: .\v.exe -o v.c cmd/v && gcc -Werror -I ./thirdparty/stdatomic/win -municode -w v.c
-      - name: Install dependencies
-        run: |
-          .\v.exe setup-freetype
-          .\.github\workflows\windows-install-sqlite.bat
-      - name: v doctor
-        run: |
-          ./v doctor
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests
-        run: |
-          .\v.exe -silent test-self
-  #    - name: Test
-  #      run: |
-  #        .\v.exe -silent test-all
-      - name: Test v->js
-        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-      - name: Test v binaries
-        run: ./v build-vbinaries
-      - name: Build examples
-        run: ./v build-examples
-      - name: v2 self compilation
-        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
-
-  windows-msvc:
-    runs-on: windows-2019
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc msvc
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Build
-        run: |
-          echo %VFLAGS%
-          echo $VFLAGS
-          .\make.bat -msvc
-          .\v.exe -cflags /WX self
-      - name: Install dependencies
-        run: |
-          .\v.exe setup-freetype
-          .\.github\workflows\windows-install-sqlite.bat
-      - name: v doctor
-        run: |
-          ./v doctor
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Self tests
-        run: |
-          ./v -cg cmd\tools\vtest-self.v
-          ./v -silent test-self
-  #    - name: Test
-  #      run: |
-  #        .\v.exe -silent test-all
-      - name: Test v->js
-        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-      - name: Test v binaries
-        run: ./v build-vbinaries
-      - name: Build examples
-        run: ./v build-examples
-      - name: v2 self compilation
-        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
-
-  windows-tcc:
-    runs-on: windows-2019
-    timeout-minutes: 121
-    env:
-      VFLAGS: -cc tcc -no-retry-compilation
-      VJOBS: 1
-      VTEST_SHOW_START: 1
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12.x
-      - name: Build with make.bat -tcc
-        run: |
-          .\make.bat -tcc
-      - name: Test new v.c
-        run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -I ./thirdparty/stdatomic/win -Werror -w -ladvapi32 -bt10 v.c
-      - name: Install dependencies
-        run: |
-          .\v.exe setup-freetype
-          .\.github\workflows\windows-install-sqlite.bat
-      - name: v doctor
-        run: |
-          ./v doctor
-
-      - name: Verify `v test` works
-        run: |
-          .\v.exe cmd/tools/test_if_v_test_system_works.v
-          .\cmd\tools\test_if_v_test_system_works.exe
-
-      - name: Verify `v vlib/v/gen/c/coutput_test.v` works
-        run: |
-          .\v.exe vlib/v/gen/c/coutput_test.v
-
-      - name: Make sure running TCC64 instead of TCC32
-        run: ./v test .github\workflows\make_sure_ci_run_with_64bit_compiler_test.v
-
-      - name: Test ./v doc -v clipboard *BEFORE building tools*
-        run: ./v doc -v clipboard
-
-      - name: Test v build-tools
-        run: ./v -W build-tools
-
-      - name: Test ./v doc clipboard
-        run: ./v doc clipboard
-
-      - name: Self tests
-        run: ./v test-self
-
-      - name: Test v->js
-        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-      - name: Test v binaries
-        run: ./v build-vbinaries
-      - name: Build examples
-        run: ./v build-examples
-      - name: v2 self compilation
-        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
-
-        ##      ## tcc32
-        ##      - name: Build with make.bat -tcc32
-        ##        run: |
-        ##          Remove-Item -Recurse -Force .\thirdparty\tcc
-        ##          .\v.exe wipe-cache
-        ##          .\make.bat -tcc32
-        ##      - name: Test new v.c
-        ##        run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -I ./thirdparty/stdatomic/win -Werror -g -w -ladvapi32 -bt10 v.c
-        ##      - name: v doctor
-        ##        run: ./v doctor
-        ##
-        ##      - name: Verify `v test` works
-        ##        run: |
-        ##          .\v.exe cmd/tools/test_if_v_test_system_works.v
-        ##          .\cmd\tools\test_if_v_test_system_works.exe
-        ##
-        ##      - name: Verify `v vlib/v/gen/c/coutput_test.v` works
-        ##        run: |
-        ##          .\v.exe vlib/v/gen/c/coutput_test.v
-        ##
-        ##      - name: Make sure running TCC32 instead of TCC64
-        ##        run: ./v -stats .github\workflows\make_sure_ci_run_with_32bit_compiler_test.v
-        ##
-        ##      - name: Test v build-tools
-        ##        run: ./v -W build-tools
-        ##
-        ##      - name: Test ./v doc clipboard
-        ##        run: ./v doc clipboard
-        ##
-        ##      - name: Self tests
-        ##        run: ./v test-self
-        ##      - name: Test v->js
-        ##        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-        ##      - name: Test v binaries
-        ##        run: ./v build-vbinaries
-        ##      - name: Build examples
-        ##        run: ./v build-examples
-        ##      - name: v2 self compilation
-        ##        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
-
-  alpine-docker-musl-gcc:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    container:
-      # Alpine docker pre-built container
-      image: thevlang/vlang:alpine-build
-      env:
-        V_CI_MUSL: 1
-        VFLAGS: -cc gcc
-      volumes:
-        - ${{github.workspace}}:/opt/vlang
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Show Environment
-        run: |
-          echo "PWD:"
-          pwd
-          echo "ENVIRONMENT:"
-          env
-          echo "C Compiler:"
-          gcc --version
-
-      - name: Build V
-        run: CC=gcc make
-
-      - name: Test V fixed tests
-        run: ./v -silent test-self
-
-
-  #  ubuntu-autofree-selfcompile:
-  #    runs-on: ubuntu-20.04
-  #    timeout-minutes: 121
-  #    env:
-  #      VFLAGS: -cc gcc
-  #    steps:
-  #    - uses: actions/checkout@v2
-  #    - name: Build V
-  #      run: make -j4
-  #    - name: V self compilation with -autofree
-  #      run: ./v -o v2 -autofree cmd/v && ./v2 -o v3 -autofree cmd/v && ./v3 -o v4 -autofree cmd/v
-
-
-  #   ubuntu-musl:
-  #     runs-on: ubuntu-20.04
-  #     timeout-minutes: 121
-  #     env:
-  #       VFLAGS: -cc musl-gcc
-  #       V_CI_MUSL: 1
-  #     steps:
-  #     - uses: actions/checkout@v2
-  #     - uses: actions/setup-node@v1
-  #       with:
-  #         node-version: 12.x
-  #     - name: Install dependencies
-  #       run: |
-  #          sudo apt-get install --quiet -y musl musl-tools libssl-dev sqlite3 libsqlite3-dev valgrind
-  #     - name: Build v
-  #       run: echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
-  # #    - name: Test v binaries
-  # #      run: ./v build-vbinaries
-  # ##    - name: Test v->js
-  # ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
-  #     - name: quick debug
-  #       run: ./v -stats vlib/strconv/format_test.v
-  #     - name: Self tests
-  #       run: ./v -silent test-self
-
-  # Ubuntu docker pre-built container
-  ubuntu-musl:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    container:
-      image: thevlang/vlang:ubuntu-build
-      env:
-        V_CI_MUSL: 1
-        V_CI_UBUNTU_MUSL: 1
-        VFLAGS: -cc musl-gcc
-      volumes:
-        - ${{github.workspace}}:/opt/vlang
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Build V
-        run: |
-          echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
-      - name: Verify `v test` works
-        run: |
-          echo $VFLAGS
-          ./v cmd/tools/test_if_v_test_system_works.v
-          ./cmd/tools/test_if_v_test_system_works
-      - name: Test V fixed tests
-        run: |
-          ./v -silent test-self

.github/workflows/containers_ci.yml

@@ -0,0 +1,91 @@
+name: Containers CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: build-containers-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+
+  alpine-docker-musl-gcc:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 181
+    container:
+      # Alpine docker pre-built container
+      image: thevlang/vlang:alpine-build
+      env:
+        V_CI_MUSL: 1
+        VFLAGS: -cc gcc
+      volumes:
+        - ${{github.workspace}}:/opt/vlang
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Show Environment
+        run: |
+          echo "PWD:"
+          pwd
+          echo "ENVIRONMENT:"
+          env
+          echo "C Compiler:"
+          gcc --version
+
+## TODO: fix the container thevlang/vlang:alpine-build, instead of using apk add here:
+      - name: Add dependencies
+        run: |
+          apk add libexecinfo-static
+          apk add libexecinfo-dev
+          apk add libc6-compat
+
+      - name: Build V
+        run: CC=gcc make
+
+      - name: All code is formatted
+        run: ./v test-cleancode
+
+      - name: Run only essential tests
+        run: VTEST_JUST_ESSENTIAL=1 ./v test-self
+
+  ubuntu-docker-musl:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    container:
+      image: thevlang/vlang:ubuntu-build
+      env:
+        V_CI_MUSL: 1
+        V_CI_UBUNTU_MUSL: 1
+        VFLAGS: -cc musl-gcc -gc none
+      volumes:
+        - ${{github.workspace}}:/opt/vlang
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Build V
+        run: |
+          echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+
+      - name: All code is formatted
+        run: ./v test-cleancode
+
+      - name: Test V fixed tests
+        run: ./v test-self

.github/workflows/cross_ci.yml

@@ -12,11 +12,12 @@ jobs:
 
   macos-cross:
     runs-on: macOS-latest
-    timeout-minutes: 15
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 25
     env:
       VFLAGS: -cc clang
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 10
 
@@ -41,18 +42,14 @@ jobs:
           ./v -os windows cmd/v
           ./v -os windows examples/2048/2048.v
 
-      - name: Compile to raw Android (non-graphic) compatible
-        run: |
-          # Test that V can compile non-graphic app to Android compatible code *without* using the -apk flag
-          ./v -os android examples/toml.v
-
   linux-cross:
     runs-on: ubuntu-20.04
-    timeout-minutes: 15
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 25
     env:
       VFLAGS: -cc tcc -no-retry-compilation
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 10
       - name: Install dependencies
@@ -62,6 +59,7 @@ jobs:
           sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev
           sudo apt-get install --quiet -y mingw-w64 wine-stable winetricks
           ## sudo apt-get install --quiet -y wine32
+
       - name: Turn off the wine crash dialog
         run: winetricks nocrashdialog
 
@@ -71,14 +69,14 @@ jobs:
       - name: v.c can be compiled and run with -os cross
         run: |
           ./v -os cross -o /tmp/v.c cmd/v
-          gcc  -g -std=gnu11 -I ./thirdparty/stdatomic/nix -w -o v_from_vc /tmp/v.c  -lm -lpthread
+          gcc  -g -std=gnu11 -w -o v_from_vc /tmp/v.c  -lm -lpthread
           ls -lart v_from_vc
           ./v_from_vc version
 
       - name: v_win.c can be compiled and run with -os windows
         run: |
-          ./v -os windows -o /tmp/v_win.c cmd/v
-          x86_64-w64-mingw32-gcc -I ./thirdparty/stdatomic/win /tmp/v_win.c -std=c99 -w -municode -o v_from_vc.exe
+          ./v -cc msvc -os windows -o /tmp/v_win.c cmd/v
+          x86_64-w64-mingw32-gcc /tmp/v_win.c -std=c99 -w -municode -o v_from_vc.exe
           ls -lart v_from_vc.exe
           wine64 ./v_from_vc.exe version
 
@@ -93,19 +91,12 @@ jobs:
           ./v -os windows examples/2048/2048.v
           ls -lart examples/2048/2048.exe
 
-      - name: toml.v can be compiled to raw Android C
-        run: |
-          # Test that V can compile non-graphic app to Android compatible code *without* using the -apk flag
-          ./v -os android examples/toml.v
-
-
   windows-cross:
     runs-on: windows-2019
-    timeout-minutes: 15
-    env:
-      VFLAGS: -cc msvc
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 25
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Build
         run: |
           echo %VFLAGS%
@@ -113,8 +104,8 @@ jobs:
           .\make.bat -msvc
       - name: TODO v_win.c can be compiled and run with -os windows
         run: |
-          .\v.exe -os windows -showcc -o v2.exe cmd\v
-          .\v.exe -os windows -o v_win.c cmd\v
+          .\v.exe -os windows -cc msvc -showcc -o v2.exe cmd\v
+          .\v.exe -os windows -cc msvc -o v_win.c cmd\v
           dir v2.exe
           dir v_win.c
           .\v2.exe version

.github/workflows/debug.yml

@@ -10,10 +10,10 @@ jobs:
     env:
       VFLAGS: -cc msvc
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Build
         run: |
           echo %VFLAGS%
@@ -25,16 +25,17 @@ jobs:
           .\v.exe setup-freetype
           .\.github\workflows\windows-install-sqlite.bat
       - name: v doctor
-        run: |
-          ./v doctor
+        run: ./v doctor
       - name: Verify `v test` works
         run: |
           ./v cmd/tools/test_if_v_test_system_works.v
           ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
       - name: Self tests
         run: |
           ./v -cg cmd\tools\vtest-self.v
-          ./v -silent test-self
+          ./v test-self
       - name: Test v->js
         run: ./v -o hi.js examples/hello_v_js.v && node hi.js
       - name: Test v binaries
@@ -43,4 +44,3 @@ jobs:
         run: ./v build-examples
       - name: v2 self compilation
         run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
-

.github/workflows/docs_ci.yml

@@ -1,18 +1,47 @@
 name: Docs CI
 
-### Run on *EVERY* commit. The documentation *SHOULD* stay valid, and
-### the developers should receive early warning if they break it.
-on: [push, pull_request]
+### Run on *EVERY* .v or .md related commit.
+### The documentation *SHOULD* stay valid, and the developers should receive
+### early warning, if they break it.
+
+on:
+  push:
+    paths-ignore:
+      - "**.yml"
+  pull_request:
+    paths-ignore:
+      - "**.yml"
 
 jobs:
   check-markdown:
     runs-on: ubuntu-20.04
     timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Build V
         run: make
       - name: Check markdown line length & code examples
         run: ./v check-md -hide-warnings .
-      ## NB: -hide-warnings is used here, so that the output is less noisy,
-      ## thus real errors are easier to spot.
+        ## NB: -hide-warnings is used here, so that the output is less noisy,
+        ## thus real errors are easier to spot.
+
+  report-missing-fn-doc:
+    runs-on: ubuntu-20.04
+    timeout-minutes: 5
+    env:
+      MOPTIONS: --relative-paths --exclude /vlib/v/ --exclude /builtin/linux_bare/ --exclude /testdata/ --exclude /tests/
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build V
+        run: make
+
+      - name: Checkout previous v
+        uses: actions/checkout@v3
+        with:
+          repository: vlang/v
+          ref: master   # important
+          path: pv
+
+      - name: Check against parent commit
+        run: |
+          ./v missdoc --diff $MOPTIONS pv/vlib vlib

.github/workflows/gen_vc_ci.yml

@@ -10,10 +10,11 @@ on:
 jobs:
   build-vc:
     runs-on: ubuntu-latest
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     env:
       VREPO: github.com/vlang/vc.git
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Build V
         run: make
       - name: Regenerate v.c and v_win.c
@@ -31,7 +32,7 @@ jobs:
           rm -rf vc/v.c vc/v_win.c
 
           ./v -o vc/v.c -os cross cmd/v
-          ./v -o vc/v_win.c -os windows cmd/v
+          ./v -o vc/v_win.c -os windows -cc msvc cmd/v
 
           sed -i "1s/^/#define V_COMMIT_HASH \"$COMMIT_HASH\"\n/" vc/v.c
           sed -i "1s/^/#define V_COMMIT_HASH \"$COMMIT_HASH\"\n/" vc/v_win.c

.github/workflows/gg_regressions_ci.yml

@@ -10,44 +10,46 @@ on:
 
 jobs:
   gg-regressions:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 10
     env:
       VFLAGS: -cc tcc
       DISPLAY: :99
+      LIBGL_ALWAYS_SOFTWARE: true
+      VTMP: /tmp
     steps:
       - name: Checkout V
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Build local v
-        run: make -j4
+        run: make
 
       - name: Setup dependencies
         run: |
-          # xvfb                     : xvfb (installed by openrndr/setup-opengl@v1.1)
+          # imagemagick              : convert, mogrify
+          # xvfb                     : xvfb
           # openimageio-tools        : idiff
           # libxcursor-dev libxi-dev : V gfx deps
-          # mesa-common-dev          : For headless rendering
+          # libgl1-mesa-dri          : For headless rendering / software DRI driver (LIBGL_ALWAYS_SOFTWARE=true)
           # freeglut3-dev            : Fixes graphic apps compilation with tcc
-          sudo apt-get install imagemagick openimageio-tools mesa-common-dev libxcursor-dev libxi-dev freeglut3-dev
+          sudo apt-get update
+          sudo apt-get install imagemagick openimageio-tools libgl1-mesa-dri xvfb libxcursor-dev libxi-dev freeglut3-dev xsel xclip
           wget https://raw.githubusercontent.com/tremby/imgur.sh/c98345d/imgur.sh
+          git clone https://github.com/Larpon/gg-regression-images gg-regression-images
           chmod +x ./imgur.sh
 
-      - uses: openrndr/setup-opengl@v1.1
-      - uses: actions/checkout@v2
-        with:
-          repository: Larpon/gg-regression-images
-          path: gg-regression-images
-
       - name: Sample and compare
         id: compare
         continue-on-error: true
         run: |
-          Xvfb $DISPLAY -screen 0 1280x1024x24 &
+          Xvfb $DISPLAY -screen 0 1280x1024x24 -fbdir /var/tmp/ &
+          sleep 1; while [ ! -f /var/tmp/Xvfb_screen0 ]; do sleep 0.5; done # give xvfb time to start, even on slow CI runs
           ./v gret -t ./gg-regression-images/vgret.v_examples.toml -v ./gg-sample_images ./gg-regression-images
 
       - name: Upload regression to imgur
         if: steps.compare.outcome != 'success'
         run: |
           ./imgur.sh /tmp/fail.png
+          ./imgur.sh /tmp/diff.png
           exit 1

.github/workflows/linux_ci.yml

@@ -0,0 +1,398 @@
+name: Code CI Linux
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: build-ci-linux-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  ubuntu-tcc:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    env:
+      VFLAGS: -cc tcc -no-retry-compilation
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
+          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
+          ## The following is needed for examples/wkhtmltopdf.v
+          wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_amd64.deb
+          sudo apt-get install --quiet -y xfonts-75dpi xfonts-base
+          sudo apt-get install --quiet -y expect
+          sudo dpkg -i wkhtmltox_0.12.6-1.focal_amd64.deb
+      - name: Build v
+        run: |
+          echo $VFLAGS
+          make
+          ./v test-cleancode
+          ./v -d debug_malloc -d debug_realloc -o v cmd/v
+          ./v -cg -cstrict -o v cmd/v
+          # Test v -realloc arena allocation
+          ./v -o vrealloc -prealloc cmd/v && ./vrealloc -o v3 cmd/v && ./v3 -o v4 cmd/v
+      - name: Test v->c
+        run: |
+          thirdparty/tcc/tcc.exe -version
+          ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
+      #        ./v test-all
+      - name: v self compilation
+        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
+      - name: v self compilation with -skip-unused
+        run: ./v -skip-unused -o v2 cmd/v && ./v2 -skip-unused -o v3 cmd/v && ./v3 -skip-unused -o v4 cmd/v
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
+      - name: Self tests
+        run: ./v test-self
+      # - name: Self tests (-cstrict)
+      #   run: V_CI_CSTRICT=1 ./v -cstrict test-self
+      - name: Test time functions in a timezone UTC-12
+        run: TZ=Etc/GMT+12 ./v test vlib/time/
+      - name: Test time functions in a timezone UTC-3
+        run: TZ=Etc/GMT+3 ./v test vlib/time/
+      - name: Test time functions in a timezone UTC+3
+        run: TZ=Etc/GMT-3 ./v test vlib/time/
+      - name: Test time functions in a timezone UTC+12
+        run: TZ=Etc/GMT-12 ./v test vlib/time/
+      - name: Test time functions in a timezone using daylight saving (Europe/Paris)
+        run: TZ=Europe/Paris ./v test vlib/time/
+      - name: Build examples
+        run: ./v -W build-examples
+      - name: Test building v tools
+        run: ./v -W build-tools
+      - name: Test v binaries
+        run: ./v build-vbinaries
+      - name: Run a VSH script
+        run: ./v run examples/v_script.vsh
+      - name: Test v tutorials
+        run: ./v tutorials/building_a_simple_web_blog_with_vweb/code/blog
+      - name: Build cmd/tools/fast
+        run: cd cmd/tools/fast && ../../../v fast.v && ./fast
+      - name: V self compilation with -usecache
+        run: |
+          unset VFLAGS
+          ./v -usecache examples/hello_world.v && examples/hello_world
+          ./v  -o v2 -usecache cmd/v
+          ./v2 -o v3 -usecache cmd/v
+          ./v3 version
+          ./v3 -o tetris  -usecache examples/tetris/tetris.v
+      - name: Test password input
+        run: |
+          ./v examples/password
+          ./v examples/password/password_ci.vsh
+      - name: Test readline
+        run: |
+          ./v examples/readline/readline_ci.v
+          ./v examples/readline/readline.vsh
+
+
+  ubuntu-tcc-boehm-gc:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    env:
+      VFLAGS: -cc tcc -no-retry-compilation
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
+          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
+          sudo apt-get install --quiet -y libgc-dev
+          ## The following is needed for examples/wkhtmltopdf.v
+          wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6-1/wkhtmltox_0.12.6-1.focal_amd64.deb
+          sudo apt-get install --quiet -y xfonts-75dpi xfonts-base
+          sudo dpkg -i wkhtmltox_0.12.6-1.focal_amd64.deb
+      - name: Build v
+        run: |
+          echo $VFLAGS
+          make
+      - name: Test v->c
+        run: |
+          thirdparty/tcc/tcc.exe -version
+          ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
+      - name: v self compilation with -gc boehm
+        run: |
+          ./v -gc boehm -o v2 cmd/v && ./v2 -gc boehm -o v3 cmd/v && ./v3 -gc boehm -o v4 cmd/v
+          mv v4 v
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Verify `v -gc boehm test` works
+        run: |
+          ./v -gc boehm cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
+      - name: Self tests with `-gc boehm` with V compiler using Boehm-GC itself
+        run: ./v -gc boehm test-self
+      - name: Test leak detector
+        run: |
+          ./v -gc boehm_leak -o testcase_leak vlib/v/tests/testcase_leak.vv
+          ./testcase_leak 2>leaks.txt
+          grep "Found 1 leaked object" leaks.txt && grep -P ", sz=\s?1000," leaks.txt
+      - name: Test leak detector not being active for `-gc boehm`
+        run: |
+          ./v -gc boehm -o testcase_leak vlib/v/tests/testcase_leak.vv
+          ./testcase_leak 2>leaks.txt
+          [ "$(stat -c %s leaks.txt)" = "0" ]
+      - name: Test leak detector not being active for normal compile
+        run: |
+          ./v -o testcase_leak vlib/v/tests/testcase_leak.vv
+          ./testcase_leak 2>leaks.txt
+          [ "$(stat -c %s leaks.txt)" = "0" ]
+
+  ubuntu:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
+          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
+      - name: Build V
+        run: make -j4 && ./v -cc gcc -cg -cstrict -o v cmd/v
+      - name: Valgrind v.c
+        run: valgrind --error-exitcode=1 ./v -o v.c cmd/v
+      - name: Run sanitizers
+        run: |
+          ./v -o v2 cmd/v -cflags -fsanitize=thread
+          ./v -o v3 cmd/v -cflags "-fsanitize=undefined -fno-sanitize=alignment"
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v3 -o v.c cmd/v
+      #    - name: Test V
+      #      run: ./v test-all
+      #    - name: Test v binaries
+      #      run: ./v build-vbinaries
+      ##    - name: Test v->js
+      ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+      #    - name: Build Vorum
+      #      run: git clone --depth 1 https://github.com/vlang/vorum && cd vorum && ../v . && cd ..
+      - name: Build vpm
+        run: git clone --depth 1 https://github.com/vlang/vpm && cd vpm && ../v . || ../v cmd/vpm && cd ..
+      - name: Freestanding
+        run: ./v -freestanding run vlib/os/bare/bare_example_linux.v
+      - name: V self compilation
+        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
+      - name: V self compilation with -usecache
+        run: |
+          unset VFLAGS
+          ./v -usecache examples/hello_world.v && examples/hello_world
+          ./v  -o v2     -usecache cmd/v
+          ./v2 -o v3     -usecache cmd/v
+          ./v3 version
+          ./v3 -o tetris -usecache examples/tetris/tetris.v
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
+      - name: Self tests
+        run: ./v test-self
+      - name: Self tests (-prod)
+        run: ./v -o vprod -prod cmd/v && ./vprod test-self
+      - name: Self tests (-cstrict)
+        run: VTEST_JUST_ESSENTIAL=1 V_CI_CSTRICT=1 ./v -cc gcc -cstrict test-self
+      - name: Build examples
+        run: ./v build-examples
+      - name: Build tetris.v with -autofree
+        run: ./v -autofree -experimental -o tetris examples/tetris/tetris.v
+      - name: Build option_test.v with -autofree
+        run: ./v -autofree vlib/v/tests/option_test.v
+      - name: V self compilation with -parallel-cc
+        run: |
+          ./v -o v2 -parallel-cc cmd/v
+      - name: Build modules
+        run: |
+          ./v build-module vlib/os
+          ./v build-module vlib/builtin
+          ./v build-module vlib/strconv
+          ./v build-module vlib/time
+          ./v build-module vlib/term
+          ./v build-module vlib/math
+          ./v build-module vlib/strings
+          ./v build-module vlib/v/token
+          ./v build-module vlib/v/ast
+          ./v build-module vlib/v/parser
+          ./v build-module vlib/v/gen/c
+          ./v build-module vlib/v/depgraph
+          ./v build-module vlib/os/cmdline
+      - name: native machine code generation
+        run: |
+          exit
+          ./v -o vprod -prod cmd/v
+          cd cmd/tools
+          echo "Generating a 1m line V file..."
+          ../../vprod gen1m.v
+          ./gen1m > 1m.v
+          echo "Building it..."
+          ../../vprod -backend native -o 1m 1m.v
+          echo "Running it..."
+          ls
+
+  #        ./1m
+  # run: echo "TODO" #cd examples/native && ../../v -native hello_world.v && ./hello_world
+  #    - name: Coveralls GitHub Action
+  #      uses: coverallsapp/github-action@v1.0.1
+  #      with:
+  #        github-token: ${{ secrets.GITHUB_TOKEN }}
+
+  ubuntu-clang:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    env:
+      VFLAGS: -cc clang
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
+          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
+          sudo apt-get install --quiet -y clang
+      - name: Build V
+        run: make -j4 && ./v -cc clang -cg -cstrict -o v cmd/v
+      - name: Valgrind
+        run: valgrind --error-exitcode=1 ./v -o v.c cmd/v
+      - name: Run sanitizers
+        run: |
+          ./v -o v2 cmd/v -cflags -fsanitize=memory
+          ./v -o v3 cmd/v -cflags -fsanitize=thread
+          ./v -o v4 cmd/v -cflags -fsanitize=undefined
+          ./v -o v5 cmd/v -cflags -fsanitize=address,pointer-compare,pointer-subtract
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v3 -o v.c cmd/v
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v4 -o v.c cmd/v
+          ASAN_OPTIONS=detect_leaks=0 UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v5 -o v.c cmd/v
+      - name: v self compilation
+        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
+      - name: v self compilation with -usecache
+        run: |
+          unset VFLAGS
+          ./v -usecache examples/hello_world.v && examples/hello_world
+          ./v  -o v2     -usecache cmd/v
+          ./v2 -o v3     -usecache cmd/v
+          ./v3 version
+          ./v3 -o tetris -usecache examples/tetris/tetris.v
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
+
+      - name: Self tests
+        run: ./v test-self
+      - name: Self tests (vprod)
+        run: |
+          ./v -o vprod -prod cmd/v
+          ./vprod test-self
+      - name: Self tests (-cstrict)
+        run: VTEST_JUST_ESSENTIAL=1 V_CI_CSTRICT=1 ./vprod -cstrict test-self
+
+      - name: Build examples
+        run: ./v build-examples
+      - name: Build examples with -autofree
+        run: |
+          ./v -autofree -experimental -o tetris examples/tetris/tetris.v
+      - name: Build modules
+        run: |
+          ./v build-module vlib/os
+          ./v build-module vlib/builtin
+          ./v build-module vlib/strconv
+          ./v build-module vlib/time
+          ./v build-module vlib/term
+          ./v build-module vlib/math
+          ./v build-module vlib/strings
+          ./v build-module vlib/v/token
+          ./v build-module vlib/v/ast
+          ./v build-module vlib/v/parser
+          ./v build-module vlib/v/gen/c
+          ./v build-module vlib/v/depgraph
+          ./v build-module vlib/os/cmdline
+      - name: native machine code generation
+        run: |
+          exit
+          ./v -o vprod -prod cmd/v
+          cd cmd/tools
+          echo "Generating a 1m line V file..."
+          ../../vprod gen1m.v
+          ./gen1m > 1m.v
+          echo "Building it..."
+          ../../vprod -backend native -o 1m 1m.v
+          echo "Running it..."
+          ls
+
+
+#  ubuntu-autofree-selfcompile:
+#    runs-on: ubuntu-20.04
+#    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+#    timeout-minutes: 121
+#    env:
+#      VFLAGS: -cc gcc
+#    steps:
+#    - uses: actions/checkout@v3
+#    - name: Build V
+#      run: make -j4
+#    - name: V self compilation with -autofree
+#      run: ./v -o v2 -autofree cmd/v && ./v2 -o v3 -autofree cmd/v && ./v3 -o v4 -autofree cmd/v
+
+
+#   ubuntu-musl:
+#     runs-on: ubuntu-20.04
+#    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+#     timeout-minutes: 121
+#     env:
+#       VFLAGS: -cc musl-gcc
+#       V_CI_MUSL: 1
+#     steps:
+#     - uses: actions/checkout@v3
+#     - uses: actions/setup-node@v3
+#       with:
+#         node-version: 16
+#     - name: Install dependencies
+#       run: |
+#          sudo apt-get install --quiet -y musl musl-tools libssl-dev sqlite3 libsqlite3-dev valgrind
+#     - name: Build v
+#       run: echo $VFLAGS && make -j4 && ./v -cg -o v cmd/v
+# #    - name: Test v binaries
+# #      run: ./v build-vbinaries
+# ##    - name: Test v->js
+# ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+#     - name: quick debug
+#       run: ./v -stats vlib/strconv/format_test.v
+#     - name: Self tests
+#       run: ./v test-self

.github/workflows/macos_ci.yml

@@ -0,0 +1,122 @@
+name: Code CI macos
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: build-ci-macos-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  macos:
+    runs-on: macOS-12
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    env:
+      VFLAGS: -cc clang
+      PKG_CONFIG_PATH: /usr/local/opt/pkgconfig:/usr/local/opt/libpq/lib/pkgconfig:/usr/local/opt/openssl@3/lib/pkgconfig:/opt/homebrew/lib/pkgconfig:/opt/homebrew/opt/libpq/lib/pkgconfig:/opt/homebrew/opt/openssl@3/lib/pkgconfig
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Install dependencies
+        run: |
+          echo "PKG_CONFIG_PATH is '$PKG_CONFIG_PATH'"
+          brew install libpq openssl
+          export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
+          echo "LIBRARY_PATH is '$LIBRARY_PATH'"
+      - name: Build V
+        run: make -j4 && ./v -cg -cstrict -o v cmd/v
+      - name: Run sanitizers
+        run: |
+          ./v -o v2 cmd/v -cflags -fsanitize=undefined
+          UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1 ./v2 -o v.c cmd/v
+      - name: Build V using V
+        run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v
+      - name: Test symlink
+        run: ./v symlink
+      - name: Build vpm
+        run: git clone --depth 1 https://github.com/vlang/vpm && cd vpm && ../v . || ../v cmd/vpm && cd ..
+      #    - name: Set up pg database
+      #      run: |
+      #        pg_ctl -D /usr/local/var/postgres -l /usr/local/var/postgres/server.log start
+      #        psql -d postgres -c 'select rolname from pg_roles'
+      #        psql -d postgres -c 'create database customerdb;'
+      #        psql -d customerdb -f examples/database/pg/mydb.sql
+      #    - name: Test v->c
+      #      run: ./v test-all
+      #    - name: Test v binaries
+      #      run: ./v build-vbinaries
+      ##    - name: Test v->js
+      ##      run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: VJOBS=1 ./v test-cleancode
+      - name: Self tests
+        run: VJOBS=1 ./v test-self
+      - name: Build examples
+        run: ./v build-examples
+      - name: Build examples with -autofree
+        run: |
+          ./v -autofree -o tetris examples/tetris/tetris.v
+          ./v -autofree -o blog tutorials/building_a_simple_web_blog_with_vweb/code/blog
+      - name: Build examples with -prod
+        run: |
+          ./v -prod examples/news_fetcher.v
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Test ved
+        run: |
+          git clone --depth 1 https://github.com/vlang/ved
+          cd ved && ../v -o ved .
+          ../v -autofree .
+          ../v -prod .
+          cd ..
+#      - name: Test c2v
+#        run: |
+#          git clone --depth 1 https://github.com/vlang/c2v
+#          cd c2v && ../v -o c2v .
+#          ../v .
+#          ../v run tests/run_tests.vsh
+#          ../v -experimental -w c2v_test.v
+#          cd ..
+      - name: Build V UI examples
+        run: |
+          git clone --depth 1 https://github.com/vlang/ui
+          cd ui
+          mkdir -p ~/.vmodules
+          ln -s $(pwd) ~/.vmodules/ui
+          ../v examples/rectangles.v
+          ## ../v run examples/build_examples.vsh
+      - name: V self compilation with -usecache
+        run: |
+          unset VFLAGS
+          ./v -usecache examples/hello_world.v && examples/hello_world
+          ./v  -o v2 -usecache cmd/v
+          ./v2 -o v3 -usecache cmd/v
+          ./v3 version
+          ./v3 -o tetris  -usecache examples/tetris/tetris.v
+      - name: V self compilation with -parallel-cc
+        run: |
+          ./v -o v2 -parallel-cc cmd/v
+      - name: Test password input
+        run: |
+          ./v examples/password
+          ./v examples/password/password_ci.vsh
+      - name: Test readline
+        run: |
+          ./v examples/readline/readline_ci.v
+          ./v examples/readline/readline.vsh

.github/workflows/make_sure_ci_run_with_32bit_compiler_test.v

@@ -1,5 +1,7 @@
-fn test_ci_run_with_32bit_compiler() {
-    $if x64 {
-        assert false
-    }	
-}
+fn test_ci_run_with_32bit_compiler() {
+	$if x64 && tinyc {
+		// TODO: uncomment that next assert when tcc32 vs tcc64 detection on windows works reliably
+		// assert false
+		assert true
+	}
+}

.github/workflows/module_docs_ci.yml

@@ -10,7 +10,7 @@ jobs:
   build-module-docs:
     runs-on: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Build V
         run: make
       - name: Build module documentation

.github/workflows/native_backend_tests_ci.yml

@@ -0,0 +1,79 @@
+name: native backend CI
+
+on:
+  push:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'vlib/v/gen/native/'
+      - 'cmd/tools/builders/**.v'
+      - 'vlib/builtin/**.v'
+      - 'vlib/v/ast/**.v'
+      - 'vlib/v/scanner/**.v'
+      - 'vlib/v/parser/**.v'
+      - 'vlib/v/checker/**.v'
+      - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
+      - 'vlib/v/cflag/**.v'
+      - 'vlib/v/live/**.v'
+      - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
+      - 'vlib/v/preludes/**.v'
+      - 'vlib/v/gen/native/**.v'
+      - 'vlib/v/gen/native/tests/**.v'
+  pull_request:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'vlib/v/gen/native/'
+      - 'cmd/tools/builders/**.v'
+      - 'vlib/builtin/**.v'
+      - 'vlib/v/ast/**.v'
+      - 'vlib/v/scanner/**.v'
+      - 'vlib/v/parser/**.v'
+      - 'vlib/v/checker/**.v'
+      - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
+      - 'vlib/v/cflag/**.v'
+      - 'vlib/v/live/**.v'
+      - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
+      - 'vlib/v/preludes/**.v'
+      - 'vlib/v/gen/native/**.v'
+      - 'vlib/v/gen/native/tests/**.v'
+
+concurrency:
+  group: native-backend-ci-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  native-backend:
+    strategy:
+      matrix:
+        os: [
+          ubuntu-20.04,
+          macos-11, macos-12,
+          windows-2019, windows-2022
+        ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install linker
+        if: ${{ startsWith(matrix.os, 'ubuntu')}}
+        run: |
+          sudo apt-get install --quiet -y binutils
+
+      - name: Build V with make.bat
+        if: ${{ startsWith(matrix.os, 'windows') }}
+        run: |
+          .\make.bat
+          .\v.exe symlink -githubci
+      - name: Build V with make
+        if: ${{ !startsWith(matrix.os, 'windows') }}
+        run: |
+          make
+          ./v symlink -githubci
+
+      - name: Test the native backend
+        run: v test vlib/v/gen/native/

.github/workflows/other_ci.yml

@@ -15,36 +15,39 @@ concurrency:
 jobs:
   no-gpl-by-accident:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 15
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: No GPL licensed code, should be added accidentally
         run: |
           ! grep -r --exclude="*.yml" "a GPL license" .
 
   code-formatting:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 15
     env:
       VFLAGS: -cc gcc
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Environment info
         run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
       - name: Build local v
         run: make -j4
       - name: v test-cleancode
-        run: ./v -silent test-cleancode
+        run: ./v test-cleancode
       - name: v test-fmt
-        run: ./v -silent test-fmt
+        run: ./v test-fmt
 
   performance-regressions:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 15
     env:
       VFLAGS: -cc gcc
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Environment info
         run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
       - name: Build local v
@@ -60,26 +63,39 @@ jobs:
       - name: Repeat -o hw.c examples/hello_world.v
         run: cmd/tools/repeat --max_time 251 --series 3 --count 20 --nmins 2 --nmaxs 5 --warmup 3 --fail_percent 10 -t 'cd {T} ; ./v -show-timings -o hw.c examples/hello_world.v' . ./vmaster
       - name: Repeat -o v.c cmd/v
-        run: cmd/tools/repeat --max_time 1501 --series 3 --count 20 --nmins 2 --nmaxs 5 --warmup 3 --fail_percent 10 -t 'cd {T} ; ./v -show-timings -o v.c cmd/v' . ./vmaster
+        run: cmd/tools/repeat --max_time 1701 --series 3 --count 20 --nmins 2 --nmaxs 5 --warmup 3 --fail_percent 10 -t 'cd {T} ; ./v -show-timings -o v.c cmd/v' . ./vmaster
 
   misc-tooling:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 121
     env:
       VFLAGS: -cc tcc -no-retry-compilation
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 10
+
       - name: Install dependencies
         run: |
           sudo apt-get update
-          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-          sudo apt-get install --quiet -y xfonts-75dpi xfonts-base
+          sudo apt-get install --quiet -y libsodium-dev libssl-dev sqlite3 libsqlite3-dev postgresql libpq-dev valgrind
+          sudo apt-get install --quiet -y libfreetype6-dev libxi-dev libxcursor-dev libgl-dev xfonts-75dpi xfonts-base
+          sudo apt-get install --quiet -y g++-9 g++-11
+
       - name: Build v
         run: make
 
+      - name: g++-9 version
+        run: g++-9 --version
+      - name: V self compilation with g++ and -std=c++11
+        run: ./v -cc g++-9 -no-std -cflags -std=c++11 -o v2 cmd/v && ./v2 -cc g++-9 -no-std -cflags -std=c++11 -o v3 cmd/v
+
+      - name: g++-11 version
+        run: g++-11 --version
+      - name: V self compilation with g++ and -std=c++20
+        run: ./v -cc g++-11 -no-std -cflags -std=c++20 -o v2 cmd/v && ./v2 -cc g++-11 -no-std -cflags -std=c++20 -o v3 cmd/v
+
       - name: Ensure V can be compiled with -autofree
         run: ./v -autofree -o v2 cmd/v  ## NB: this does not mean it runs, but at least keeps it from regressing
 
@@ -97,28 +113,14 @@ jobs:
                  echo "compiling shader $f.glsl ..."; \
                  ./sokol-shdc --input $f.glsl --output $f.h --slang glsl330 ; \
           done
-          for vfile in examples/sokol/0?*/*.v; do echo "compiling $vfile ..."; ./v $vfile ; done
-
-      - name: Install C++ dependencies
-        run: |
-          sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev
-          sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
-          sudo apt-get install --quiet -y valgrind g++-9
-      - name: Build V
-        run: make -j4
-      - name: g++ version
-        run: g++-9 --version
-      - name: V self compilation with g++
-        run: ./v -cc g++-9 -no-std -cflags -std=c++11 -o v2 cmd/v && ./v2 -cc g++-9 -no-std -cflags -std=c++11 -o v3 cmd/v
-  ##    - name: Running tests with g++
-  ##      run: ./v -cc g++-9 -silent test-self
-
+          ./v should-compile-all examples/sokol/*.v examples/sokol/0?*/*.v
 
   parser-silent:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 121
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install zzuf
         run: sudo apt install -qq zzuf
       - name: Build local v
@@ -151,98 +153,3 @@ jobs:
           ./v test-parser -S examples/cli_fuzz.v
           ./v test-parser -S examples/regex_example_fuzz.v
           ./v test-parser -S examples/2048/2048_fuzz.v
-
-  v-apps-compile:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 121
-    steps:
-      - uses: actions/checkout@v2
-      - name: Build V
-        run: make && sudo ./v symlink
-
-      - name: Install dependencies
-        run: sudo apt-get install --quiet -y libgc-dev
-
-      ## vls
-      - name: Clone VLS
-        run: git clone --depth 1 https://github.com/vlang/vls
-      - name: Build VLS
-        run: pushd vls; v cmd/vls ; popd
-      - name: Build VLS with -prod
-        run: pushd vls; v -prod cmd/vls; popd
-      - name: Build VLS with -gc boehm -skip-unused
-        run: pushd vls; v -gc boehm -skip-unused cmd/vls; popd
-
-      ## vsl
-      - name: Clone VSL
-        run: git clone --depth 1 https://github.com/vlang/vsl ~/.vmodules/vsl
-      - name: Install dependencies
-        run: sudo apt-get install --quiet -y --no-install-recommends gfortran liblapacke-dev libopenblas-dev libgc-dev
-      - name: Execute Tests using Pure V Backend
-        run: ~/.vmodules/vsl/bin/test
-      - name: Execute Tests using Pure V Backend with Pure V Math
-        run: ~/.vmodules/vsl/bin/test --use-cblas
-      - name: Execute Tests using Pure V Backend and Garbage Collection enabled
-        run: ~/.vmodules/vsl/bin/test --use-gc boehm
-      - name: Execute Tests using Pure V Backend with Pure V Math and Garbage Collection enabled
-        run: ~/.vmodules/vsl/bin/test --use-cblas --use-gc boehm
-
-      ## vtl
-      - name: Clone VTL
-        run: git clone --depth 1 https://github.com/vlang/vtl ~/.vmodules/vtl
-      - name: Install dependencies
-        run: sudo apt-get install --quiet -y --no-install-recommends gfortran liblapacke-dev libopenblas-dev libgc-dev
-      - name: Execute Tests using Pure V Backend
-        run: ~/.vmodules/vtl/bin/test
-      - name: Execute Tests using Pure V Backend with Pure V Math
-        run: ~/.vmodules/vtl/bin/test --use-cblas
-      - name: Execute Tests using Pure V Backend and Garbage Collection enabled
-        run: ~/.vmodules/vtl/bin/test --use-gc boehm
-      - name: Execute Tests using Pure V Backend with Pure V Math and Garbage Collection enabled
-        run: ~/.vmodules/vtl/bin/test --use-cblas --use-gc boehm
-
-      ## vab
-      - name: Clone vab
-        run: git clone --depth 1 https://github.com/vlang/vab
-      - name: Build vab
-        run: cd vab; ../v ./vab.v ; cd ..
-      - name: Build vab with -gc boehm -skip-unused
-        run: cd vab; ../v -gc boehm -skip-unused ./vab.v ; cd ..
-
-      ## gitly
-      - name: Install markdown
-        run: ./v install markdown
-      - name: Build Gitly
-        run: |
-          git clone --depth 1 https://github.com/vlang/gitly
-          cd gitly
-          ../v .
-          # ./gitly -ci_run
-          ../v -autofree .
-          ../v -o x tests/first_run.v
-          ./x
-          cd ..
-
-      ## vex
-      - name: Install Vex dependencies
-        run: sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev
-      - name: Install Vex
-        run: mkdir -p ~/.vmodules/nedpals; git clone https://github.com/nedpals/vex ~/.vmodules/nedpals/vex
-      - name: Compile the simple Vex example
-        run: ./v ~/.vmodules/nedpals/vex/examples/simple_example.v
-      - name: Compile the simple Vex example with -gc boehm -skip-unused
-        run: ./v -gc boehm -skip-unused ~/.vmodules/nedpals/vex/examples/simple_example.v
-      - name: Run Vex Tests
-        run: ./v test ~/.vmodules/nedpals/vex
-
-      ## vpm modules
-      - name: Install UI through VPM
-        run: ./v install ui
-
-      ## libsodium
-      - name: Install libsodium-dev package
-        run: sudo apt-get install --quiet -y libsodium-dev
-      - name: Installl the libsodium wrapper through VPM
-        run: ./v install libsodium
-      - name: Test libsodium
-        run: ./v test ~/.vmodules/libsodium

.github/workflows/paths_ci.yml

@@ -16,11 +16,12 @@ jobs:
 
   space-paths-linux:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 30
     env:
       MY_V_PATH: '你好 my $path, @с интервали'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           path: ${{env.MY_V_PATH}}
       - name: Build V
@@ -41,11 +42,12 @@ jobs:
 
   space-paths-macos:
     runs-on: macOS-latest
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 30
     env:
       MY_V_PATH: '你好 my $path, @с интервали'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           path: ${{env.MY_V_PATH}}
       - name: Build V
@@ -69,6 +71,7 @@ jobs:
 
   space-paths-windows:
     runs-on: windows-2022
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 30
     env:
       MY_V_PATH: 'path with some $punctuation, and some spaces'
@@ -84,7 +87,7 @@ jobs:
       ## and that happens even for gcc builds, not just tcc ones
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           path: ${{env.MY_V_PATH}}
       - name: Build V

.github/workflows/periodic.yml

@@ -1,58 +0,0 @@
-name: Periodic
-
-on:
-  schedule:
-    - cron:  '0 */2 * * *'
-
-jobs:
-  network-tests-ubuntu:
-    runs-on: ubuntu-20.04
-    timeout-minutes: 30
-    env:
-        V_CI_PERIODIC: 1
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install dependencies
-      run: sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
-    - name: Build v
-      run: make -j4
-    - name: Symlink V
-      run:  sudo ./v symlink
-##    - name: Run network tests
-##      run: ./v -d network test vlib/net
-
-
-  network-tests-macos:
-    runs-on: macOS-latest
-    timeout-minutes: 30
-    env:
-        V_CI_PERIODIC: 1
-    steps:
-    - uses: actions/checkout@v2
-    - name: Setup openssl library path
-      run: export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
-    - name: Build V
-      run:  make -j4
-    - name: Symlink V
-      run:  sudo ./v symlink
-    - name: Ensure thirdparty/cJSON/cJSON.o is compiled, before running tests.
-      run:  ./v examples/json.v
-##    - name: Run network tests
-##      run: ./v -d network test vlib/net
-
-
-  network-windows-msvc:
-    runs-on: windows-2019
-    timeout-minutes: 30
-    env:
-        V_CI_PERIODIC: 1
-        VFLAGS: -cc msvc
-    steps:
-    - uses: actions/checkout@v2
-    - name: Build
-      run: |
-        echo %VFLAGS%
-        echo $VFLAGS
-        .\make.bat -msvc
-##    - name: Run network tests
-##      run: .\v.exe -d network test vlib/net

.github/workflows/periodic_ci.yml

@@ -0,0 +1,60 @@
+name: Periodic
+
+on:
+  schedule:
+    - cron: '0 */6 * * *'
+
+jobs:
+  network-tests-ubuntu:
+    runs-on: ubuntu-20.04
+    if: github.event.ref == 'refs/heads/master' && github.event.repository.full_name == 'vlang/v'
+    timeout-minutes: 30
+    env:
+      V_CI_PERIODIC: 1
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install dependencies 1
+        run: sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev
+      - name: Build v
+        run: make
+      - name: Symlink V
+        run: sudo ./v symlink
+        ## - name: Run network tests
+        ##   run: ./v -d network test vlib/net
+
+
+  network-tests-macos:
+    runs-on: macOS-latest
+    if: github.event.ref == 'refs/heads/master' && github.event.repository.full_name == 'vlang/v'
+    timeout-minutes: 30
+    env:
+      V_CI_PERIODIC: 1
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup openssl library path
+        run: export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
+      - name: Build V
+        run: make
+      - name: Symlink V
+        run: sudo ./v symlink
+      - name: Ensure thirdparty/cJSON/cJSON.o is compiled, before running tests.
+        run: ./v examples/json.v
+        ## - name: Run network tests
+        ##   run: ./v -d network test vlib/net
+
+  network-windows-msvc:
+    runs-on: windows-2019
+    if: github.event.ref == 'refs/heads/master' && github.event.repository.full_name == 'vlang/v'
+    timeout-minutes: 30
+    env:
+      V_CI_PERIODIC: 1
+      VFLAGS: -cc msvc
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build
+        run: |
+          echo %VFLAGS%
+          echo $VFLAGS
+          .\make.bat -msvc
+          ## - name: Run network tests
+          ##   run: .\v.exe -d network test vlib/net

.github/workflows/sanitized_ci.yml

@@ -15,10 +15,17 @@ on:
   push:
     paths:
       - '!**'
+      - '!**.md'
+      - '!**.yml'
       - 'cmd/tools/vtest*'
+      - 'cmd/tools/builders/**.v'
       - 'vlib/builtin/**.v'
       - 'vlib/strconv/**.v'
       - 'vlib/strings/**.v'
+      - 'vlib/math/**.v'
+      - 'vlib/math/big/**.v'
+      - 'vlib/arrays/**.v'
+      - 'vlib/datatypes/**.v'
       - 'vlib/os/**.v'
       - 'vlib/sync/**.v'
       - 'vlib/v/tests/**.v'
@@ -27,18 +34,25 @@ on:
       - 'vlib/v/parser/**.v'
       - 'vlib/v/checker/**.v'
       - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
       - 'vlib/v/cflag/**.v'
       - 'vlib/v/live/**.v'
       - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
       - 'vlib/v/preludes/**.v'
       - 'vlib/v/embed_file/**.v'
   pull_request:
     paths:
       - '!**'
       - 'cmd/tools/vtest*'
+      - 'cmd/tools/builders/**.v'
       - 'vlib/builtin/**.v'
       - 'vlib/strconv/**.v'
       - 'vlib/strings/**.v'
+      - 'vlib/math/**.v'
+      - 'vlib/math/big/**.v'
+      - 'vlib/arrays/**.v'
+      - 'vlib/datatypes/**.v'
       - 'vlib/os/**.v'
       - 'vlib/sync/**.v'
       - 'vlib/v/tests/**.v'
@@ -47,9 +61,11 @@ on:
       - 'vlib/v/parser/**.v'
       - 'vlib/v/checker/**.v'
       - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
       - 'vlib/v/cflag/**.v'
       - 'vlib/v/live/**.v'
       - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
       - 'vlib/v/preludes/**.v'
       - 'vlib/v/embed_file/**.v'
 
@@ -60,16 +76,17 @@ concurrency:
 jobs:
   tests-sanitize-undefined-clang:
     runs-on: ubuntu-20.04
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
       VFLAGS: -cc clang
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Install dependencies
         run: |
           sudo apt-get update
@@ -77,7 +94,9 @@ jobs:
           sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
           sudo apt-get install clang
       - name: Build V
-        run: make -j4 && ./v -cg -cstrict -o v cmd/v
+        run: make && ./v -cg -cstrict -o v cmd/v
+      - name: Ensure code is well formatted
+        run: ./v test-cleancode
       - name: Self tests (-fsanitize=undefined)
         run: ./v -cflags "-fsanitize=undefined" -o v2 cmd/v && ./v2 -cflags -fsanitize=undefined test-self
       - name: Build examples (V compiled with -fsanitize=undefined)
@@ -85,23 +104,26 @@ jobs:
 
   tests-sanitize-undefined-gcc:
     runs-on: ubuntu-20.04
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
       VFLAGS: -cc gcc
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Install dependencies
         run: |
           sudo apt update
           sudo apt-get install --quiet -y postgresql libpq-dev libssl-dev sqlite3 libsqlite3-dev valgrind
           sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
       - name: Build V
-        run: make -j4 && ./v -cg -cstrict -o v cmd/v
+        run: make && ./v -cg -cstrict -o v cmd/v
+      - name: Ensure code is well formatted
+        run: ./v test-cleancode
       - name: Self tests (-fsanitize=undefined)
         run: ./v -cflags "-fsanitize=undefined" -o v2 cmd/v && ./v2 -cflags -fsanitize=undefined test-self
       - name: Build examples (V compiled with -fsanitize=undefined)
@@ -109,16 +131,17 @@ jobs:
 
   tests-sanitize-address-clang:
     runs-on: ubuntu-20.04
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
       VFLAGS: -cc clang
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Install dependencies
         run: |
           sudo apt update
@@ -126,7 +149,9 @@ jobs:
           sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
           sudo apt-get install clang
       - name: Build V
-        run: make -j4 && ./v -cg -cstrict -o v cmd/v
+        run: make && ./v -cg -cstrict -o v cmd/v
+      - name: Ensure code is well formatted
+        run: ./v test-cleancode
       - name: Self tests (-fsanitize=address)
         run: ASAN_OPTIONS=detect_leaks=0 ./v -cflags "-fsanitize=address,pointer-compare,pointer-subtract" test-self
       - name: Self tests (V compiled with -fsanitize=address)
@@ -138,22 +163,28 @@ jobs:
 
   tests-sanitize-address-msvc:
     runs-on: windows-2019
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
       VFLAGS: -cc msvc
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Build
         run: |
           echo %VFLAGS%
           echo $VFLAGS
           .\make.bat -msvc
           .\v.exe self
+      - name: Ensure code is well formatted
+        run: |
+          .\v.exe fmt -verify vlib/builtin/ vlib/v/scanner/ vlib/v/parser/ vlib/v/gen/
+      ## TODO: check to see why `v test-cleancode` does not work with msvc on windows
+
       ##      - name: Install dependencies
       ##        run: |
       ##          .\v.exe setup-freetype
@@ -164,16 +195,17 @@ jobs:
 
   tests-sanitize-address-gcc:
     runs-on: ubuntu-20.04
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
       VFLAGS: -cc gcc
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Install dependencies
         run: |
           sudo apt update
@@ -181,7 +213,9 @@ jobs:
           sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
           sudo apt-get install clang
       - name: Build V
-        run: make -j4 && ./v -cg -cstrict -o v cmd/v
+        run: make && ./v -cg -cstrict -o v cmd/v
+      - name: Ensure code is well formatted
+        run: ./v test-cleancode
       - name: Self tests (-fsanitize=address)
         run: ASAN_OPTIONS=detect_leaks=0 ./v -cflags -fsanitize=address test-self
       - name: Self tests (V compiled with -fsanitize=address)
@@ -193,16 +227,17 @@ jobs:
 
   tests-sanitize-memory-clang:
     runs-on: ubuntu-20.04
-    timeout-minutes: 180
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 240
     env:
-      VFLAGS: -cc clang
+      VFLAGS: -cc clang -gc none
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
-          node-version: 12.x
+          node-version: 16
       - name: Install dependencies
         run: |
           sudo apt update
@@ -210,11 +245,14 @@ jobs:
           sudo apt-get install --quiet -y libfreetype6-dev  libxi-dev libxcursor-dev libgl-dev
           sudo apt-get install clang
       - name: Build V
-        run: make -j4 && ./v -cc clang -cg -cstrict -o v cmd/v
+        run: make && ./v -cc clang -cg -cstrict -o v cmd/v
+      - name: Ensure code is well formatted
+        run: ./v test-cleancode
       - name: Self tests (-fsanitize=memory)
         run: ./v -cflags -fsanitize=memory test-self
       - name: Self tests (V compiled with -fsanitize=memory)
-        run:
-          ./v -cflags -fsanitize=memory -o v cmd/v && ./v -cc tcc test-self -msan-compiler
+        run: |
+          ./v -cflags -fsanitize=memory -o v cmd/v
+          ./v -cc tcc test-self -msan-compiler
       - name: Build examples (V compiled with -fsanitize=memory)
         run: ./v build-examples

.github/workflows/sdl_ci.yml

@@ -4,18 +4,25 @@ on:
   push:
     paths-ignore:
       - "**.md"
+      - "**.yml"
   pull_request:
     paths-ignore:
       - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: sdl-ci-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
 
 jobs:
   v-compiles-sdl-examples:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 30
     env:
       VFLAGS: -cc tcc
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Build V
         run: make && sudo ./v symlink
 
@@ -40,7 +47,5 @@ jobs:
 
       - name: Build sdl examples
         run: |
-          for example in sdl/examples/*; do
-              echo "v $example"
-              v "$example";
-          done
+          v shader sdl/examples/sdl_opengl_and_sokol
+          v should-compile-all sdl/examples/

.github/workflows/toml_ci.yml

@@ -10,7 +10,8 @@ on:
 
 jobs:
   toml-module-pass-external-test-suites:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 30
     env:
       TOML_BS_TESTS_PATH: vlib/toml/tests/testdata/burntsushi/toml-test
@@ -23,7 +24,7 @@ jobs:
       VTEST_TOML_DO_YAML_CONVERSION: 1
     steps:
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install dependencies
         run: |
           sudo apt-get update
@@ -44,7 +45,7 @@ jobs:
           git -C $TOML_BS_TESTS_PATH checkout $TOML_BS_TESTS_PINNED_COMMIT
 
       - name: Run BurntSushi TOML tests
-        run: ./v vlib/toml/tests/burntsushi.toml-test_test.v
+        run: ./v vlib/toml/tests/burntsushi_toml_test.v
 
         # Tests found at gist
       - name: Get large_toml_file_test.toml
@@ -60,7 +61,7 @@ jobs:
           git -C $TOML_IARNA_TESTS_PATH checkout $TOML_IARNA_TESTS_PINNED_COMMIT
 
       - name: Run iarna TOML tests
-        run: ./v -gc boehm vlib/toml/tests/iarna.toml-spec-tests_test.v
+        run: ./v -gc boehm vlib/toml/tests/iarna_toml_spec_test.v
 
         # Tests found at https://github.com/alexcrichton/toml-rs
       - name: Clone alexcrichton/toml-rs
@@ -69,4 +70,4 @@ jobs:
           git -C $TOML_AC_TESTS_PATH checkout $TOML_AC_TESTS_PINNED_COMMIT
 
       - name: Run alexcrichton TOML tests
-        run: ./v vlib/toml/tests/alexcrichton.toml-rs-tests_test.v
+        run: ./v vlib/toml/tests/alexcrichton_toml_rs_test.v

.github/workflows/v_apps_and_modules_compile_ci.yml

@@ -0,0 +1,175 @@
+name: V Apps and Modules
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+concurrency:
+  group: build-v-apps-and-modules-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  v-apps-compile:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build V
+        run: make && sudo ./v symlink
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y libgc-dev   libsodium-dev libssl-dev sqlite3 libsqlite3-dev    valgrind    libfreetype6-dev libxi-dev libxcursor-dev libgl-dev xfonts-75dpi xfonts-base
+          sudo apt-get install --quiet -y --no-install-recommends gfortran liblapacke-dev libopenblas-dev ## for vsl/vtl
+          sudo apt-get install --quiet -y --no-install-recommends sassc ## needed by gitly
+          sudo apt-get install --quiet -y --no-install-recommends libhdf5-cpp-103 libhdf5-dev libhdf5-mpi-dev hdf5-tools libopenmpi-dev opencl-headers liblapacke-dev libopenblas-dev ## needed by VSL
+
+      - name: Build vlang/vab
+        run: |
+          echo "Install VAB"
+          v install vab
+          echo "Build vab"
+          v ~/.vmodules/vab
+          echo "Build vab with -gc boehm -skip-unused"
+          v -gc boehm -skip-unused ~/.vmodules/vab
+
+      - name: Build vlang/ved
+        run: |
+          git clone --depth 1 https://github.com/vlang/ved
+          cd ved && ../v -o ved .
+          ../v -autofree .
+          ../v -prod .
+          cd ..
+
+      - name: Build vlang/pdf
+        run: |
+          v install pdf
+          echo "PDF examples should compile"
+          v should-compile-all ~/.vmodules/pdf/examples
+
+      - name: Build vlang/libsodium
+        run: |
+          echo "Install the libsodium wrapper"
+          v install libsodium
+          echo "Test libsodium"
+          VJOBS=1 v test ~/.vmodules/libsodium
+
+      - name: Build vlang/coreutils
+        run: |
+          echo "Clone Coreutils"
+          git clone --depth 1 https://github.com/vlang/coreutils /tmp/coreutils
+          echo "Build Coreutils"
+          cd /tmp/coreutils; make
+
+#      - name: Build vlang/gitly
+#        run: |
+#          echo "Install markdown"
+#          v install markdown
+#          echo "Install pcre"
+#          v install pcre
+#          echo "Clone Gitly"
+#          git clone https://github.com/vlang/gitly /tmp/gitly
+#          echo "Build Gitly"
+#          v /tmp/gitly
+#          ## echo "Build Gitly with -autofree"
+#          ## v -autofree /tmp/gitly
+#          echo "Compile gitly.css from gitly.scss"
+#          sassc /tmp/gitly/src/static/css/gitly.scss > /tmp/gitly/src/static/css/gitly.css
+#          echo "Run first_run.v"
+#          v run /tmp/gitly/tests/first_run.v
+#          # /tmp/gitly/gitly -ci_run
+
+      - name: Build V Language Server (VLS) vlang/vls
+        run: |
+          echo "Clone VLS"
+          git clone --depth 1 https://github.com/vlang/vls /tmp/vls
+          echo "Build VLS"
+          v /tmp/vls/cmd/vls
+          echo "Build VLS with -prod"
+          v -prod /tmp/vls/cmd/vls
+          echo "Build VLS with -gc boehm -skip-unused"
+          v -gc boehm -skip-unused /tmp/vls/cmd/vls
+          echo "Test VLS with gcc"
+          v -cc gcc test /tmp/vls
+
+      - name: Build vlang/go2v
+        run: |
+          echo "Clone Go2V"
+          git clone --depth=1 https://github.com/vlang/go2v /tmp/go2v/
+          echo "Build Go2V"
+          v /tmp/go2v/
+          echo "Run Go2V tests"
+          VJOBS=1 v -stats test /tmp/go2v/
+
+      - name: Install UI through VPM and make sure its examples compile
+        run: |
+          echo "Official VPM modules should be installable"
+          v install ui
+          echo "Examples of UI should compile"
+          v ~/.vmodules/ui/examples/build_examples.vsh
+
+      - name: Build vlang/vsl
+        run: |
+          echo "Installing dependencies"
+          sudo apt-get install --quiet -y --no-install-recommends \
+            gfortran \
+            libxi-dev \
+            libxcursor-dev \
+            mesa-common-dev \
+            liblapacke-dev \
+            libopenblas-dev \
+            libgc-dev \
+            libgl1-mesa-dev \
+            libopenmpi-dev \
+            opencl-headers
+          echo "Install VSL"
+          v install vsl
+          echo "Execute Tests using Pure V Backend"
+          ~/.vmodules/vsl/bin/test
+          echo "Execute Tests using Pure V Backend with Pure V Math"
+          ~/.vmodules/vsl/bin/test --use-cblas
+          echo "Execute Tests using Pure V Backend and Garbage Collection enabled"
+          ~/.vmodules/vsl/bin/test --use-gc boehm
+          echo "Execute Tests using Pure V Backend with Pure V Math and Garbage Collection enabled"
+          ~/.vmodules/vsl/bin/test --use-cblas --use-gc boehm
+
+      - name: Build vlang/vtl
+        run: |
+          echo "Install VTL"
+          v install vtl
+          echo "Install dependencies"
+          echo "Execute Tests using Pure V Backend"
+          ~/.vmodules/vtl/bin/test
+          echo "Execute Tests using Pure V Backend with Pure V Math"
+          ~/.vmodules/vtl/bin/test --use-cblas
+          echo "Execute Tests using Pure V Backend and Garbage Collection enabled"
+          ~/.vmodules/vtl/bin/test --use-gc boehm
+          echo "Execute Tests using Pure V Backend with Pure V Math and Garbage Collection enabled"
+          ~/.vmodules/vtl/bin/test --use-cblas --use-gc boehm
+
+      - name: Build vlang/adventofcode
+        run: |
+          echo "Clone the AdventOfCode repo"
+          git clone --depth 1 https://github.com/vlang/adventofcode  /tmp/adventofcode
+          echo "Install dependencies"
+          v install pcre
+          echo "Execute Tests"
+          cd /tmp/adventofcode && v run verify.v
+
+
+#      - name: Build VEX
+#        run: |
+#          echo "Install Vex"
+#          v install nedpals.vex
+#          echo "Compile all of the Vex examples"
+#          v should-compile-all ~/.vmodules/nedpals/vex/examples
+#          echo "Compile the simple Vex example with -skip-unused"
+#          v -skip-unused ~/.vmodules/nedpals/vex/examples/simple_example.v
+#          echo "Run Vex Tests"
+#          v test ~/.vmodules/nedpals/vex

.github/workflows/vab_ci.yml

@@ -11,6 +11,7 @@ on:
 jobs:
   vab-compiles-v-examples:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 121
     env:
       VAB_FLAGS: --api 30 --build-tools 29.0.0 -v 3
@@ -20,24 +21,18 @@ jobs:
         distribution: 'adopt'
         java-version: 8
 
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Build V
       run: make && sudo ./v symlink
 
-    - name: Checkout vab
-      uses: actions/checkout@v2
-      with:
-        repository: vlang/vab
-        path: vab
-
-    - name: Build vab
+    - name: Install vab
       run: |
-        cd vab
-        v -g vab.v
-        sudo ln -s $(pwd)/vab /usr/local/bin/vab
+        v install vab
+        v -g ~/.vmodules/vab
+        sudo ln -s ~/.vmodules/vab/vab /usr/local/bin/vab
 
     - name: Run tests
-      run: v test vab
+      run: v test ~/.vmodules/vab
 
     - name: Run vab --help
       run: vab --help
@@ -53,3 +48,27 @@ jobs:
           safe_name=$(echo "$example" | sed 's%/%-%' | sed 's%\.%-%' )
           vab examples/$example -o apks/$safe_name.apk
         done
+
+  v-compiles-os-android:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 10
+    steps:
+    - uses: actions/checkout@v3
+    - name: Build V
+      run: make && sudo ./v symlink
+
+    - name: Install vab
+      run: |
+        v install vab
+        v -g ~/.vmodules/vab
+        sudo ln -s ~/.vmodules/vab/vab /usr/local/bin/vab
+
+    - name: Run vab --help
+      run: vab --help
+
+    - name: Run vab doctor
+      run: vab doctor
+
+    - name: Check `v -os android` *without* -apk flag
+      run: .github/workflows/android_cross_compile.vsh

.github/workflows/vinix-kernel.yml

@@ -1,34 +0,0 @@
-name: Build Vinix kernel
-
-on:
-  pull_request:
-    paths-ignore:
-      - "**.md"
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - "**.md"
-
-jobs:
-  vinix-build:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install dependencies
-        run: sudo apt-get update && sudo apt-get install build-essential meson -y
-      - name: Build V
-        run: make
-      - name: Clone current Vinix
-        run: |
-          git clone https://github.com/vlang/vinix.git --depth 1
-      - name: Clone current mlibc
-        run: git clone https://github.com/managarm/mlibc.git --depth=1
-      - name: Patch mlibc for Vinix
-        run: cd mlibc && patch -p1 < ../vinix/patches/mlibc/0001-Vinix-specific-changes.patch || true
-      - name: Install mlibc headers
-        run: mkdir mlibc-build && cd mlibc-build && meson --cross-file ../vinix/cross_file.txt --prefix=/ -Dheaders_only=true ../mlibc && ninja && mkdir ../mlibc-headers && DESTDIR=`realpath ../mlibc-headers` ninja install
-      - name: Attempt to build the Vinix kernel (debug)
-        run: cd vinix/kernel && make PROD=false CFLAGS="-D__vinix__ -O2 -g -pipe -I../../mlibc-headers/include" V="../../v" && make clean
-      - name: Attempt to build the Vinix kernel (prod)
-        run: cd vinix/kernel && make PROD=true  CFLAGS="-D__vinix__ -O2 -g -pipe -I../../mlibc-headers/include" V="../../v" && make clean

.github/workflows/vinix_kernel_ci.yml

@@ -0,0 +1,37 @@
+name: Build Vinix kernel
+
+on:
+  pull_request:
+    paths-ignore:
+      - "**.md"
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  vinix-build:
+    runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    env:
+      VFLAGS: -gc none
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install build-essential meson -y
+
+      - name: Build V
+        run: make
+
+      - name: Clone current Vinix
+        run: git clone https://github.com/vlang/vinix.git
+
+      - name: Attempt to build the Vinix kernel (debug)
+        run: cd vinix/kernel && make PROD=false CFLAGS="-D__vinix__ -O2 -g -pipe" V="../../v" && make clean
+
+      - name: Attempt to build the Vinix kernel (prod)
+        run: cd vinix/kernel && make PROD=true CFLAGS="-D__vinix__ -O2 -g -pipe" V="../../v" && make clean

.github/workflows/wasm_backend_tests_ci.yml

@@ -0,0 +1,119 @@
+name: wasm backend CI
+
+on:
+  push:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'cmd/tools/builders/**.v'
+      - 'vlib/builtin/**.v'
+      - 'vlib/v/ast/**.v'
+      - 'vlib/v/scanner/**.v'
+      - 'vlib/v/parser/**.v'
+      - 'vlib/v/checker/**.v'
+      - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
+      - 'vlib/v/cflag/**.v'
+      - 'vlib/v/live/**.v'
+      - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
+      - 'vlib/v/preludes/**.v'
+      - 'vlib/v/gen/wasm/**.v'
+      - 'vlib/v/gen/wasm/tests/**.v'
+  pull_request:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'cmd/tools/builders/**.v'
+      - 'vlib/builtin/**.v'
+      - 'vlib/v/ast/**.v'
+      - 'vlib/v/scanner/**.v'
+      - 'vlib/v/parser/**.v'
+      - 'vlib/v/checker/**.v'
+      - 'vlib/v/gen/c/**.v'
+      - 'vlib/v/builder/**.v'
+      - 'vlib/v/cflag/**.v'
+      - 'vlib/v/live/**.v'
+      - 'vlib/v/util/**.v'
+      - 'vlib/v/markused/**.v'
+      - 'vlib/v/preludes/**.v'
+      - 'vlib/v/gen/wasm/**.v'
+      - 'vlib/v/gen/wasm/tests/**.v'
+
+concurrency:
+  group: wasm-backend-ci-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  wasm-backend-ubuntu:
+    runs-on: ubuntu-22.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y clang gcc
+
+      - name: Build V
+        run: make -j4 && ./v symlink -githubci
+
+      - name: Install binaryen as build dependency for the V WASM backend
+        run: ./v cmd/tools/install_binaryen.vsh
+
+      - name: Build the V WASM backend
+        run: ./v -cc clang -showcc -v cmd/tools/builders/wasm_builder.v
+
+      - name: Test the WASM backend
+        run: ./v test vlib/v/gen/wasm/tests/
+
+      - name: Build examples
+        run: VTEST_ONLY=wasm ./v build-examples
+
+  wasm-backend-macos:
+    runs-on: macOS-12
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build V
+        run: make -j4 && ./v symlink -githubci
+
+      - name: Install binaryen as build dependency for the V WASM backend
+        run: ./v cmd/tools/install_binaryen.vsh
+
+      - name: Build the V WASM backend
+        run: ./v -cc clang -showcc -v cmd/tools/builders/wasm_builder.v
+
+      - name: Test the WASM backend
+        run: ./v test vlib/v/gen/wasm/tests/
+
+      - name: Build examples
+        run: VTEST_ONLY=wasm ./v build-examples
+
+  wasm-backend-windows:
+    runs-on: windows-2022
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build V
+        run: .\make.bat -msvc
+      - name: Symlink V
+        run: .\v.exe symlink -githubci
+
+      - name: Install binaryen as build dependency for the V WASM backend
+        run: v cmd/tools/install_binaryen.vsh
+
+      - name: Build the V WASM backend
+        run: v -cc msvc -showcc -v cmd/tools/builders/wasm_builder.v
+
+      - name: Test the WASM backend
+        run: v -stats test vlib/v/gen/wasm/tests/
+
+      - name: Build examples
+        run: $env:VTEST_ONLY='wasm'; v build-examples

.github/workflows/wasm_wabt_tests_ci.yml

@@ -0,0 +1,73 @@
+name: wasm wabt validate tests CI
+
+on:
+  push:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'vlib/builtin/**.v'
+      - 'vlib/wasm/**.v'
+      - 'vlib/wasm/tests/**.v'
+  pull_request:
+    paths:
+      - '!**'
+      - '!**.md'
+      - 'vlib/builtin/**.v'
+      - 'vlib/wasm/**.v'
+      - 'vlib/wasm/tests/**.v'
+
+concurrency:
+  group: wasm-wabt-ci-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  wasm-wabt-ubuntu:
+    runs-on: ubuntu-22.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 31
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build V
+        run: make && ./v symlink -githubci
+
+      - name: Install wabt to get the wasm-validate executable
+        run: v cmd/tools/install_wabt.vsh
+
+      - name: Test the WASM backend
+        run: v test vlib/wasm/
+
+  wasm-wabt-macos:
+    runs-on: macOS-12
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 31
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build V
+        run: make && ./v symlink -githubci
+
+      - name: Install wabt to get the wasm-validate executable
+        run: v cmd/tools/install_wabt.vsh
+
+      - name: Test the WASM backend
+        run: v test vlib/wasm/
+
+  wasm-wabt-windows:
+    runs-on: windows-2022
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 31
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build V
+        run: .\make.bat -msvc
+
+      - name: Symlink V
+        run: .\v.exe symlink -githubci
+
+      - name: Install wabt to get the wasm-validate executable
+        run: v cmd/tools/install_wabt.vsh
+
+      - name: Test the WASM backend
+        run: v test vlib/wasm/

.github/workflows/websockets_ci.yml

@@ -11,11 +11,12 @@ on:
 jobs:
   websocket_tests:
     runs-on: ubuntu-20.04
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
     timeout-minutes: 121
     env:
       VFLAGS: -cc tcc -no-retry-compilation
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install dependencies
         run: sudo apt-get install --quiet -y libssl-dev
       - name: Build v

.github/workflows/windows-install-sqlite.bat

@@ -1,12 +1,11 @@
 @echo off
 
-curl -L https://www.sqlite.org/2020/sqlite-amalgamation-3320300.zip -o sqlite-amalgamation-3320300.zip
+curl -L https://www.sqlite.org/2022/sqlite-amalgamation-3380200.zip -o sqlite-amalgamation-3380200.zip
 
-unzip sqlite-amalgamation-3320300.zip -d thirdparty\
+unzip sqlite-amalgamation-3380200.zip -d thirdparty\
 
-del thirdparty\sqlite-amalgamation-3320300\shell.c
+del thirdparty\sqlite-amalgamation-3380200\shell.c
 
-move /y thirdparty\sqlite-amalgamation-3320300  thirdparty\sqlite
+move /y thirdparty\sqlite-amalgamation-3380200 thirdparty\sqlite
 
 dir thirdparty\sqlite
-

.github/workflows/windows_ci.yml

@@ -0,0 +1,223 @@
+name: Code CI Windows
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: build-ci-windows-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  windows-gcc:
+    runs-on: windows-2019
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 181
+    env:
+      VFLAGS: -cc gcc
+      VERBOSE_MAKE: 1
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Build
+        run: |
+          gcc --version
+          .\make.bat -gcc
+      - name: Test new v.c
+        run: |
+          .\v.exe -o v.c cmd/v
+          gcc -Werror -municode -w v.c
+      - name: Install dependencies
+        run: |
+          .\v.exe setup-freetype
+          .\.github\workflows\windows-install-sqlite.bat
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+      - name: All code is formatted
+        run: ./v test-cleancode
+      - name: Self tests
+        run: .\v.exe test-self
+        #    - name: Test
+        #      run: .\v.exe test-all
+      - name: Test time functions in a timezone UTC-12
+        run: |
+          tzutil /s "Dateline Standard Time"
+          ./v test vlib/time/
+      - name: Test time functions in a timezone UTC-3
+        run: |
+          tzutil /s "Greenland Standard Time"
+          ./v test vlib/time/
+      - name: Test time functions in a timezone UTC+3
+        run: |
+          tzutil /s "Russian Standard Time"
+          ./v test vlib/time/
+      - name: Test time functions in a timezone UTC+12
+        run: |
+          tzutil /s "New Zealand Standard Time"
+          ./v test vlib/time/
+      - name: Test v->js
+        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+      - name: Test v binaries
+        run: ./v build-vbinaries
+      - name: Build examples
+        run: ./v build-examples
+      - name: v2 self compilation
+        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
+
+  windows-msvc:
+    runs-on: windows-2019
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 181
+    env:
+      VFLAGS: -cc msvc
+      VERBOSE_MAKE: 1
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Build
+        run: |
+          echo %VFLAGS%
+          echo $VFLAGS
+          .\make.bat -msvc
+          .\v.exe -cflags /WX self
+      - name: Install dependencies
+        run: |
+          .\v.exe setup-freetype
+          .\.github\workflows\windows-install-sqlite.bat
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Verify `v test` works
+        run: |
+          echo $VFLAGS
+          ./v cmd/tools/test_if_v_test_system_works.v
+          ./cmd/tools/test_if_v_test_system_works
+### TODO: test-cleancode fails with msvc. Investigate why???
+##      - name: All code is formatted
+##        run: ./v test-cleancode
+      - name: Self tests
+        run: |
+          ./v -cg cmd\tools\vtest-self.v
+          ./v test-self
+  #    - name: Test
+  #      run: .\v.exe test-all
+      - name: Test v->js
+        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+      - name: Test v binaries
+        run: ./v build-vbinaries
+      - name: Build examples
+        run: ./v build-examples
+      - name: v2 self compilation
+        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
+
+  windows-tcc:
+    runs-on: windows-2019
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
+    env:
+      VFLAGS: -cc tcc -no-retry-compilation
+      VJOBS: 1
+      VTEST_SHOW_START: 1
+      VERBOSE_MAKE: 1
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Build with make.bat -tcc
+        run: |
+          .\make.bat -tcc
+      - name: Test new v.c
+        run: |
+          .\v.exe -o v.c cmd/v
+          .\thirdparty\tcc\tcc.exe -Werror -w -ladvapi32 -bt10 v.c
+      - name: Install dependencies
+        run: |
+          .\v.exe setup-freetype
+          .\.github\workflows\windows-install-sqlite.bat
+      - name: v doctor
+        run: |
+          ./v doctor
+      - name: Verify `v test` works
+        run: |
+          .\v.exe cmd/tools/test_if_v_test_system_works.v
+          .\cmd\tools\test_if_v_test_system_works.exe
+      - name: Verify `v vlib/v/gen/c/coutput_test.v` works
+        run: |
+          .\v.exe vlib/v/gen/c/coutput_test.v
+      - name: Make sure running TCC64 instead of TCC32
+        run: ./v test .github\workflows\make_sure_ci_run_with_64bit_compiler_test.v
+      - name: Test ./v doc -v clipboard *BEFORE building tools*
+        run: ./v doc -v clipboard
+      - name: Test v build-tools
+        run: ./v -W build-tools
+      - name: All code is formatted
+        run: ./v test-cleancode
+      - name: Self tests
+        run: ./v test-self
+      - name: Test v->js
+        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+      - name: Test v binaries
+        run: ./v build-vbinaries
+      - name: Build examples
+        run: ./v build-examples
+      - name: v2 self compilation
+        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v && .\v3.exe -o v4.exe cmd/v
+      - name: v2 self compilation with -gc boehm
+        run: .\v.exe -o v2.exe -gc boehm cmd/v && .\v2.exe -o v3.exe -gc boehm cmd/v && .\v3.exe -o v4.exe -gc boehm cmd/v
+
+        ##      ## tcc32
+        ##      - name: Build with make.bat -tcc32
+        ##        run: |
+        ##          Remove-Item -Recurse -Force .\thirdparty\tcc
+        ##          .\v.exe wipe-cache
+        ##          .\make.bat -tcc32
+        ##      - name: Test new v.c
+        ##        run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -Werror -g -w -ladvapi32 -bt10 v.c
+        ##      - name: v doctor
+        ##        run: ./v doctor
+        ##
+        ##      - name: Verify `v test` works
+        ##        run: |
+        ##          .\v.exe cmd/tools/test_if_v_test_system_works.v
+        ##          .\cmd\tools\test_if_v_test_system_works.exe
+        ##
+        ##      - name: Verify `v vlib/v/gen/c/coutput_test.v` works
+        ##        run: |
+        ##          .\v.exe vlib/v/gen/c/coutput_test.v
+        ##
+        ##      - name: Make sure running TCC32 instead of TCC64
+        ##        run: ./v -stats .github\workflows\make_sure_ci_run_with_32bit_compiler_test.v
+        ##
+        ##      - name: Test v build-tools
+        ##        run: ./v -W build-tools
+        ##
+        ##      - name: Test ./v doc clipboard
+        ##        run: ./v doc clipboard
+        ##
+        ##      - name: Self tests
+        ##        run: ./v test-self
+        ##      - name: Test v->js
+        ##        run: ./v -o hi.js examples/hello_v_js.v && node hi.js
+        ##      - name: Test v binaries
+        ##        run: ./v build-vbinaries
+        ##      - name: Build examples
+        ##        run: ./v build-examples
+        ##      - name: v2 self compilation
+        ##        run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v

.gitignore

@@ -31,6 +31,10 @@ a.out
 /v.c.out
 /v_old
 /v_old.exe
+/vold
+/vold.exe
+/vnew
+/vnew.exe
 .vrepl_temp.v
 fns.txt
 .noprefix.vrepl_temp.v
@@ -57,6 +61,7 @@ fns.txt
 .project
 .classpath
 .c9
+.vs
 *.launch
 .settings/
 *.sublime-workspace
@@ -73,6 +78,7 @@ cachegrind.out.*
 .gdb_history
 *.dSYM
 *.def
+vgcore.*
 
 # ignore system files
 .DS_Store
@@ -102,6 +108,18 @@ flake.nix
 .envrc
 
 thirdparty/stdatomic/nix/cpp/*.h
+thirdparty/binaryen*
+thirdparty/wabt*
 
 # ignore VLS log
 vls.log
+
+# ignore v2go tmperror files
+*.tmperr
+
+*/**/tmp.*
+
+# ignore Intellij files
+.idea/
+/*.iml
+wasm.v

CHANGELOG.md

@@ -1,15 +1,444 @@
--## V 0.2.5
--*Not yet released, changelog is not full*
-- Introduce `isize` and `usize` types, deprecate `size_t` in favor of `usize`
+## V 0.3.5
+*not yet released*
+- A new VPM site: vpm.vlang.io. A better design, discoverability of packages, descriptions, most downloaded packages etc.
+- Struct fields can now be skipped during JSON/ORM serialization via `[json:'-']` and `[sql:'-']`,
+ in addition to `[skip]`. This allows having custom behavior for different serialization methods.
+- ORM: fixed a foreign key bug that could result in an extra insert.
+- Generic functions as function parameters are now supported: `fn f[T](x T, i int, f_ Fn[T]) T { `.
+- Enum values now can have attributes.
+- json: Enum value string serialization supports `[json:'alias']` to change its string values.
+- Functions can now return fixed size arrays.
+- The builtin websocket library is now thread safe.
+- Enhanced builtin csrf protection in vweb.
+- builtin: heap usage API (gc_memory_use() and gc_heap_usage())
 
--## V 0.2.4
--*Not yet released, changelog is not full*
+## V 0.3.4
+
+*30 Apr 2023*
+
+### Breaking Changes
+
+The following changes may break compilation of existing code or change behavior at runtime:
+
+- `json`: enums are serialized as strings by default, `[json_as_number]` attribute can be used for
+  the old behavior.
+
+  If you are serializing enums to JSON in your application, then you will need to add the
+  `[json_as_number]` attribute to keep the old behavior!
+
+- Variable shadowing has been completely banned (previously variable names could conflict with
+  module names).
+
+### Web
+
+- vweb now supports live page reloading.
+  The web app is instantly updated in the browser (no need to refresh the page)
+  every time a **.v** or a **.html** file is changed.
+- vweb is now significantly faster and more stable under load, due to a new multithreaded worker
+  pool, which is much more efficient at spreading the workload among all threads equally.
+- vweb now supports middleware.
+- vweb now supports controllers.
+  It's now possible to have multiple app structs to better separate logic.
+- vweb now supports overridable `.not_found()` method for custom 404 pages in vweb.
+- vweb now uses database pool.
+- Fixed multipart form parsing in vweb.
+
+### Backends
+
+- A new pure WASM backend, based on binaryen, a WASM `builtin` module, and a pure V WASM
+  serialization library.
+- Lots of fixes and new features in the native backend, including making codegen logic
+  platform independent.
+- Now code generated by the С backend, can be compiled by a C++20 compiler.
+- C backend does not generate unused interface functions now.
+
+### Compiler CLI
+
+- `v share file.v` for sharing code via the playground.
+- `v up` speed up for when it hasn't been run for a long time (**vc/** bootstrapping has been
+  optimized).
+- `v init` no longer overwrites existing `src/main.v`.
+- `v self` now uses a faster TCC backend on macOS (Intel/Apple Silicon), just like on Windows/Linux.
+- A new command line flag `-e` for running short V programs on command line: `v -e "println(2+5)"` (
+  works just like in Perl).
+- A new `-ldflags` option, in addition to `-cflags`. Works just like LDFLAGS in C.
+
+### ORM
+
+- All ORM queries now return `![]` (`Result` of an array).
+  This allows handling/propagating DB errors and simplifies working with ORM (one way).
+- Many ORM improvements: type checks for `limit/offset/order by/where`; support of reference objects
+  in `insert`; struct fields can be used with `limit/offset`; `Connection` interface.
+- ORM now supports the `like` operator:
+  ```v
+  users := sql db {
+      select from User where name like 'Bob%'
+  }
+  ```
+- A new `-d trace_orm` option to see all SQL queries generated and used by V ORM and
+  `-d trace_pg_error` to trace PG errors.
+
+### Standard Library
+
+- Added new `termios` module.
+- `net.ssl`: types using ssl contexts can now be converted to strings via `.str()`/printed
+  via `println()`.
+- `v.reflection`: added type symbol info metadata.
+- `crypto` and `math` modules have been updated to use `Result` instead of `Option`.
+- `datatypes.LinkedList[map]` now works correctly.
+- `urllib.Values.get()` now returns an Option.
+- `strconv`: `v_printf()` was made private, `v_sprintf()` was deprecated. String interpolation
+  should be used instead.
+- `net.http`: mime types have been updated to include all official types.
+- `gg`: `create_image()` now returns `!Image` instead of `Image`, allowing to handle errors.
+- `sokol`: errors during image creation no longer result in a panic, but can be handled by the
+  programmer.
+- `sokol`: macOS apps can now be quit using **Cmd+Q**.
+- `os.hostname()` and `os.loginname()` now return `Result`.
+- `strconv.atoi` optimizations.
+- `println()` now supports arrays with recursive references.
+- `termux`: support for cross-compilation from termux to other platforms.
+- `readline` module now works much better on macOS: key navigation, history, etc (now on par with
+  Linux).
+- `os`: fixed a memleak in `getline()`.
+- `os.Process` now has a `create_no_window` option (Windows only).
+- `os.Process` now has a `set_work_folder()` method to set the initial working folder of the new
+  child process.
+
+### Option as a first class type
+
+Final steps in making the Option type a first class type:
+
+- If guards now work with struct fields which are `Option` functions.
+  Such fields can now also be assigned to other fields/variables.
+- Option receivers can no longer have methods.
+- `none` can now be cast to all `Option` types, including aliases.
+- Option references are now supported: `?&Type`.
+- Arrays of `Option`s are now allowed.
+- Allow `foo := Foo{}`, when `Foo` has an Option field, that is a struct, that has a `[required]`
+  tag on its fields.
+
+### Compile-time Reflection
+
+- Compile-time interface fields evaluation.
+- Compile-time enum evaluation:
+  ```v
+  $for item in MyEnum.fields {
+      println(item.value)
+      println(item.name)
+  }
+  ```
+- Added `$option` as a compile-time reflection type representing an any Option type.
+- All special compile-time reflection types are now lowercase (`$int`, `$enum`, `$option`, etc).
+
+### Checker Improvements/Fixes
+
+- Enums can no longer be initialized like structs.
+- Capture variables can no longer shadow anonymous function params.
+- Mixing multi-return results with other types in return statements is no longer allowed.
+- Assigning anonymous structs to named structs is no longer allowed.
+- `[required]` fields are now checked for embedded structs.
+- Fixed a bug with closures with fixed array variables.
+- Builtin methods `first/last/repeat` can now be used in custom user types (previously they only
+  worked in builtin arrays).
+- Generic struct initialization no longer needs explicit types to be provided:
+  ```v
+  struct Foo[T, U] {
+  	a T
+  	b U
+  }
+
+  foo := Foo{
+  	a: 2
+  	b: 'x'
+  }
+
+  println(foo)
+  ```
+- unsafe: dereferencing nil references is no longer allowed in the following case:
+  ```v
+  a := unsafe { nil }
+  println(*a)
+  ```
+
+### OSes
+
+- Added basic QNX support.
+
+### Other changes
+
+- Lots of documentation/readme improvements.
+- Lots of playground improvements: [play.vlang.io](https://play.vlang.io), including a really cool
+  feature: "Show generated C code".
+- A new `[spawn_stack: 131072]` function attribute for controlling the max size of the stack of the
+  spawned threads.
+- Channel pop now works with an `or` block: `ch := <-self.item or { return none }`
+- `it` has been renamed to `index` in array inits.
+- "Is V still fast?" web-page has been sped up by splitting the result table into multiple years.
+
+### Development
+
+- GitHub Copilot summaries in PRs.
+
+## V 0.3.3
+*30 Jan 2023*
+- String interpolation simplified to just '${name}', enforced by vfmt, and updated in the entire code base.
+- `[]` is now used for generics instead of `<>`.
+- Various ORM fixes and improvements, including string interpolation support, type checks, fn calls in `where`.
+- Accessing a pointer map value requires an `or {}` block outside `unsafe`.
+- `math.vec` module for generic vector math including 2D, 3D, and 4D vector operations.
+- `go foo()` has been replaced with `spawn foo()` (launches an OS thread, `go` will be used for
+  upcoming coroutines instead).
+- vfmt now supports `// vfmt off` and `// vfmt on` for turning off the formatting locally for short snippets of code.
+  Useful for keeping your carefully arranged matrices intact.
+- fast.vlang.io fixes & improvements, new server.
+- New official IntelliJ plugin: https://intellij-v.github.io.
+- Lots of fixes in the type checker.
+- Match branch range expressions with consts: `match x { const1...const2 {} }`
+- Builtin stb_image.h used by gg has been updated to the latest v2.28.
+- Lots of new language documentation, a nicer table of contents.
+- Improved documentation for most of the vlib modules
+- All of vlib has been updated to use separate Option/Result types.
+- To avoid confusion, all references in the code and documentation to `Optional` have been replaced with `Option`.
+- `gg.Context` pipeline has more effects, including the `additive` effect.
+- Hot code reloading via `[live]` is now supported in imported modules, not just the main module.
+- VFS support in the builtin `sqlite` module; `sqlite.get_affected_rows_count()`.
+- `make.bat` & `v up` improvements on Windows.
+- Syntax sugar for map inits without needing explicit casts for interfaces: `all.children := { "abc": rect, "def": ui.rectangle()}`.
+- `$embed_file()` fixes, including variable args support.
+- `none` fixes: no longer allowed to be used as a separate type, `dump()` support, not allowed inside `unsafe`.
+- Much cleaner eof checks in `os`: refactor `err == IError(os.Eof{})` to `err is os.Eof`.
+- Const functions: `const y = term.yellow`, then `println(y('abc'))`.
+- Lots of work on `x.json2`, the pure V json encoder, soon to become official.
+- Improved compile time checks, like `$if x is Type {`; `$if T in [$Array, $Struct, $Alias, $Function] {`.
+- New `v.reflection` module for runtime reflection.
+- Improved `os.mv()`, which now works consistently even across different windows drives/mount points.
+- `string.trim_indent()`, useful with multi line strings, that start/end with new lines and indentation.
+- Reduced memory consumption in the `crypto` modules.
+- Installation instructions for using V on NixOS.
+- TeamCity test runner support via `v -test-runner teamcity foo_test.v`.
+- Better `make` support for OpenBSD.
+- Much improved experience for `v install pcre` on Windows (it now bundles its own .c files, so it compiles cleanly, even if the platform does not have another pcre package installed).
+- Improved vweb stability under load.
+- Improved `pg` compatibility with older PostgreSQL versions before 2014.
+- Native backend: operator support for floats, multi return.
+- V can now be compiled with tcc on latest macOS and Apple Silicon.
+- CI optimizations for faster runs.
+- Official V UI library is now licensed under MIT.
+- Deprecated `math.util` and `math.mathutil` have been removed.
+- Builtin type names can no longer be used as identifiers.
+- Generic `typeof[T]()`, `sizeof[T]()`, `isreftype[T]()` functions.
+- New official AdventOfCode repo with AOC solutions, also added to CI.
+- New time format support: `time.format_rfc3339()`.
+- `encoding.html.escape()`.
+- Deprecated `-error-limit` in favour of the documented `-message-limit` option.
+- Maps now support aliased keys.
+- Operator overloading now works with reference types.
+- Generic struct inits with nested generic structs and generic optional types are now allowed.
+- During array creation, `len:` is required when using default values for the array.
+- Optimized one byte `[]u8` arrays creation.
+- Int signedness mismatch is now checked: `cannot use literal signed integer as u8`.
+- New comptime features for fields: `field.is_<field>`, `field.is_alias`, `field.is_enum`.
+- More detailed timings in `v -show-timings`.
+- `$for in` works with alias types.
+- `v new <name> web` for quickly scaffolding new web projects.
+- All public functions in the `hash` and `encoding.base32` modules have been documented.
+- Recursive aliasing is no longer allowed (e.g. `type Alias = map[string]Alias`).
+- `sqlite`, `pg`, `mysql` have been moved to `db.sqlite`, `db.pg`, `db.mysql`.
+- New `crypto.pem` module.
+- New `map.reserve()` method.
+
+
+
+
+## V 0.3.2
+*31 Oct 2022*
+- New simplified string interpolation: `println("Hello, {name}!")`. It will be the only way, old syntax (`${name}` and `$name`)
+  will be deprecated.
+- New stunning playground with an improved look and feel, a much better and more responsive editor,
+  code sharing by link, more convenient keyboard control, reusability for potential embedding:
+  https://play.vlang.io.
+- `net.ssl` has been migrated from a dynamically linked OpenSSL to a statically linked Mbed TLS. This means that V binaries will no
+  longer have an OpenSSL dependency. OpenSSL can still be enabled via `-d use_openssl`.
+- msgpack module for decoding/encoding msgpack. (`v install msgpack`)
+- Easier custom error creation: `return MyCustomErr{}` instead of `return IError(MyCustomErr)`.
+- Lots of native backend improvements, including library calls, comptime conditionals, enums, method definitions/calls, structs.
+- Removed the need for the `[console]` attribute in Windows GUI apps.
+- All floats outputs now have `.0` conditionally appended to them to improve clarity.
+- Improved type checker: lots of new type checks and fixed checker bugs.
+- Custom integer enum types: `enum Xyz as u64 {`.
+- Some further interpreter work.
+- Improved call tracing via `-trace-calls`.
+- Most of vlib has been updated to use the new Option/Result types.
+- Lots of documentation improvements, including a better documentation of the recent Option/Result split.
+- net, net.http, vweb bugs and fixes.
+- V REPL: Home/End keys support. Lots of clean up.
+- QuadTree and RingBuffer types in `datatypes`.
+- Forward iterator for `datatypes.LinkedList<T>`, forward and backward iterators for `datatypes.DoublyLinkedList<T>`.
+- More precise WINAPI declarations for easier integration on Windows.
+- Unused last expression in `if` is now checked.
+- AST transformer fixes and optimizations.
+- cgen cleanups.
+- Lots of fixes in the builtin `dump()` function.
+- Stylistic improvements and bug fixes in vfmt.
+- Casting integers to enums now requires `unsafe{}`.
+- Improved error and warning messages.
+- A new `maps` module, similar to existing `arrays`. It has generic `filter`, `flatten`, `invert`, `to_map`, `to_array`, `from_array`
+  functions.
+- Parallel compilation now uses `sync.Pool`.
+- `utf8.is_number()`, `utf8.is_space()` functions.
+- New `encoding.base32` module.
+- `-skip-unused` fixes, soon to be made the default.
+- `gg.TouchPoint` to differentiate between different types of touch input.
+- Anonymous structs visibility issues fixed.
+- orm: support parenthesized expressions like `select from User where (name == 'Sam' && is_customer == true) || id == 1`.
+- `vweb.csrf` module.
+- `str.int()` conversion speedup (without -prod).
+- More CI tests on FreeBSD.
+
+## V 0.3.1
+*31 Aug 2022*
+- Anonymous structs.
+- Lots of bug fixes: 90% of all bugs ever submitted are closed.
+- Major improvements to the fast native backend including linking support on Linux. The goal is to be able to self host V soon.
+- Parallelized cc step. Speeds up -prod and clang/gcc compilation by 300-500% (depending on
+  the number of cores). Experimental and hidden behind a -parallel-cc flag, soon to be the default.
+- New keyword/type: `nil`. Only to be used inside `unsafe`. Replaces `voidptr(0)`.
+- V can now find code in the `src/` directory. This allows making V repos much cleaner.
+- Intel C compiler support.
+- Older macOS support (<10.12).
+- `os.mkdir()` now has an optional `mode` parameter.
+- Full termux support via `$if termux {`, more predictable logging on Android.
+- Go backend fixes.
+- More type checks.
+- DOOM is now translated/compiled and launched on CI servers. A screenshot of the running game
+  is made via `vgret` and is compared to the expected result.
+- VLS performance improvements, especially on Windows.
+- `v ls` tool for installing, for updating, and for launching VLS (V Language Server).
+- Support `assert condition, extra_message`, where the `extra_message` will be evaluated and shown if the assertion fails.
+- Anonymous sumtypes have been removed (deprecated for now) due to complicating the language and the compiler too much.
+- `encoding.csv` is now generic, supports bools, accepts a custom delimiter, and is compatible with io.Reader/io.Writer.
+- Operator overloading now works with aliases and generics.
+- `datatypes` module now uses operator overloading.
+- All `datatypes` types can be converted to V arrays.
+- `smtp` improvements including multiple recipients and base64/utf8 support.
+- `v doc` now has syntax highlighting.
+- `arrays.carray_to_varray<T>()` for converting C arrays to V arrays.
+- `strconv.v_sprintf()` has been deprecated in favor of string interpolation.
+- TOML module now supports `[toml:...]` attributes, just like the JSON module.
+- `os.walk()` is no longer recursive (still works the same).
+- Windows code has been removed from `v.c` distributed on non-Windows systems. (`v_windows.c` is used on Windows.)
+- ORM functions now return `Result`, so the errors can be handled.
+- `#preinclude` for low level C interop.
+- `net.urllib` ipv6 support.
+- Lots of fixes in `shared` types.
+- `io` has been migrated to `Result`.
+- Third party window control in Sokol.
+- Scanner optimizations.
+- `string.replace_char()`, `math.round_sig()`.
+- Improved multiplication performance in `math.big`.
+- `net.Http.Response.text` renamed to `body`.
+- Using C's #define is no longer allowed in normal V code, only in `.c.v` files.
+- V interpreter improvements.
+- `net.websocket` timeout is now configurable.
+
+
+## V 0.3
+*30 Jun 2022*
+- C to V translation via C2V: `v translate file.c`. (Demo video: [Translating DOOM from C to V, building it in under a second and running it!](https://www.youtube.com/watch?v=6oXrz3oRoEg))
+- Lots of bug fixes in V, cgen, and C interop to allow running translated DOOM.v.
+- Programs built with the V compiler no longer leak memory by default.
+- Closures. All operating systems are supported. ([Demo](https://twitter.com/v_language/status/1528710491882852352))
+- `Option` and `Result` are now separate types: `?Foo` and `!Foo` respectively. Old code will continue working for 1 year and will result in a warning/hint.
+- Hundreds of new checks in the type checker.
+- All V's backends have been split up into separate processes.  As the result, building V got 26% faster.
+- Maps and arrays can now return options: `m[bad_key] or { ... }`, `if x := arr[key] { ... }`.
+- `ustring` has been replaced with `[]rune` (works just like in Go).
+- Maps can now have non-string keys.
+- A new compiler pass for transforming the AST (doesn't slow the compiler too much, adds about 25ms to `v self`). It eliminates unreachable branches and performs other simple optimizations and transformations.
+- C backend is now parallel (just the cgen part for now).
+- Lots of compiler source code clean up and minor optimizations. The compiler got ~30% faster according to fast.vlang.io.
+- Better compiler source code organization (absolutely necessary as it's surpassed 100k loc).
+- The naming of V's integer types is now more consistent: `byte` has been renamed to `u8`.  Old code will continue working for 1 year and will result in a warning/hint.
+- The typo detector now highlights the suggested name so that it's more visible.
+- `datatypes` module now has `Heap, Queue, Stack, BSTree, LinkedList`.
+- Interfaces can now be embedded (like structs).
+- vlib now has a TOML parser, fully compatible with TOML 1.0.
+- Lots of work done on the V.js backend, including the graphics library, which has been ported to V.js.
+- JS promises, await (V.js).
+- It's now possible to do more complex array initialization by using each individual element of the array (`[]int{init: it}`).
+- Unsigned right shift operators `>>>` and `>>>=` have been added to V. (They work exactly like in Java.)
+- `-nofloat` option, which is useful for writing kernels and for embedded systems without an FPU (used in Vinix).
+- Generic interfaces.
+- TCC is now bundled with the language, this allows building V programs without an external C compiler dependency.
+- Null can be used in `unsafe` only (for example, for C interop).
+- Pointer arithmetic and comparing pointers to numbers is now also only allowed in `unsafe`.
+- Inline sumtypes.
+- New module `compress.gzip`.
+- Lots of `net`/`net.http`/`vweb` fixes (also used for the upcoming Gitly launch).
+- IPv6 support.
+- `net.http` headers are now enum fields instead of strings. This allows to avoid typos and offers autocomplete.
+- Struct field deprecation.
+- Static GC (no longer a dynamic lib dependency).
+- New various algorithms for random number generation: MT19937RNG, etc  (module `rand`).
+- Fix immutability bugs that allowed to bypass compiler immutability checks and modify const/immutable values.
+- Lots of fixes in the JSON serializer.
+- Heap allocated only structs marked with `[heap]`.
+- Significantly improve lots of error messages, make them more clear, suggest hints.
+- Bug fixes and new features in the pure V `regex` module.
+- Lots of new drawing functions in the graphics module (like `gg.draw_polygon_filled(), gg.draw_arc_empty()` etc)
+- Builtin FPS display in `gg`.
+- Latest Sokol backend in `gg`.
+- Advanced CI tests for the graphics module. Graphical apps are run on GitHub Actions instances, their output is saved to an image, uploaded, and compared to the expected result.
+- More bug fixes in generics.
+- Bug fixes in aliases. They can now fully replace the types they alias.
+- `[minify]` struct attribute for struct minification.
+- `for in` now works with fixed arrays.
+- The parser was made a bit faster by skipping `vfmt` code when not in `vfmt` mode (by using `-d vfmt`).
+- Lots of vfmt improvements, especially with comments.
+- Experimental `#[index]` syntax for negative indexing (like in Python, but needs special syntax instead of being used by default).
+- Visibility bug fixes in modules (`pub`).
+- Error propagation in complex expressions (e.g. `foo(bar()?)`).
+- Optionals can now by used in consts (`const x := opt() or {}`).
+- Lots of new documentation, including vlib modules documentation and the official V Documentation.
+- vpm improvements (including a new vpm mirror).
+- `sync` improvements including `sync.thread_id()`, `sync.Once`..
+- V can now be used to generate object files (`foo.o`) that can be used in existing C projects.
+- `-usecache` and `-skip-unused` fixes, they are close to being on by default.
+- Lots of Windows issues fixed.
+- Amazon Linux support.
+- Fixes in shared maps and arrays.
+- `term.ui` improvements, including multi byte/UTF-8 events.
+- New `crypto` modules, including `crypto.des, crypto.cipher, crypto.blowfish`.
+- Comptime fixes.
+- 4 byte bool option (`-d 4bytebool`) for compatibility with some C software.
+- `strconv` (pure V formatting module used in string interpolation) fixes and performance improvements.
+- ORM fixes (pg, mysql, sqlite). Tables are now created automatically based on the V structs, no more need in sql files to create tables for apps.
+- `volatile` keyword.
+- `"stringliteral".len` optimization (replaced by the actual number by the new `transform` pass).
+- Lots of inline assembler improvements (it's used a lot in Vinix).
+- Many new functions in the `math` module.
+- Separators in number literals: `1_000_000`.
+- `strings.Builder` optimizations and new methods.
+- Autofree fixes (still not production ready, hidden behind the `-autofree` flag).
+- Lots of Android fixes in V and in vab.
+- Lots of commits to the native backend (amd64/arm64).
+- V interpreter fixes. (Still at an early stage.)
+- Go2V translator has been started by the community, and can already translate simple programs.
+- An early version of the Go backend (`v -b go -o file.go file.v`).
+
+## V 0.2.4
+*30 Aug 2021*
+- Introduce `isize` and `usize` types, deprecate `size_t` in favor of `usize`.
+- Add `datatypes` and `datatypes.fsm` modules.
+- Add `compile_error` and `compile_warn` comptime functions.
 - Bare metal support. Vinix OS kernel is now being developed in V.
 - Builtin web framework vweb is now multithreaded, all CPU cores are used.
 - String interpolation and struct stringers are now implemented in pure V
 with a much cleaner and faster implementation. Previously libc's `sprintf`
 was used.
 - Improved `unused variable` warning. Assigning to a variable no longer marks it as used.
+*... lots of missing changelog for this version, sorry (will update a bit later)*
 
 ## V 0.2.2 - 0.2.3
 *22 Jan 2021*
@@ -49,12 +478,11 @@ from local variables.
 
 ## V 0.2
 *22 Dec 2020*
-- Compile-time memory management via `-autofree`. [Video demonstration](https://www.youtube.com/watch?v=gmB8ea8uLsM).
-It will be enabled by default in 0.3
+- Compile-time memory management via `-autofree` (not production ready yet). [Video demonstration](https://www.youtube.com/watch?v=gmB8ea8uLsM).
 - Channels and locks.
 - Thread safe typed arrays via keyword `shared`.
 - Struct embedding.
-- IO streams.
+- IO streams (`io.Reader`, `io.Writer` etc).
 - A powerful websocket module that conforms to RFC 6455 and passes the Autobahn test suite (498 client tests and 249 server tests).
 - The `net` module is now non blocking and is more feature complete providing similar API to Go.
 - V's graphics module now uses Metal/DirectX/OpenGL instead of just OpenGL.
@@ -201,7 +629,7 @@ files with compilation errors.
 - V now enforces short enum syntax (`.green` instead of `Color.green`) when it's enough.
 - V UI for macOS.
 - Interfaces have been rewritten. `[]interface` support.
-- `os.cp()` for copying files and directores.
+- `os.cp()` for copying files and directories.
 - Additional compile-time flags: `$if clang, msvc, mingw, x32, x64, big_endian, little_endian {`.
 - All C functions now have to be declared, all missing C functions have been defined.
 - Global variables (only with the `-enable-globals` flag)
@@ -264,14 +692,14 @@ used in some industries.
 - `fn init()` for module initialization.
 - `a in [1, 2, 3]` optimization: no array gets allocated.
 - Raw strings: `s := r'hello\nworld'`.
-- `if a := func() { }` syntax for handling optionals.
+- `if a := func() { }` syntax for handling options.
 - f32/f64 comparison now uses machine epsilon by default.
 
 
 ## V 0.1.21
 *30 Sep 2019*
 
-- `none` keyword for optionals.
+- `none` keyword for options.
 - Solaris support.
 - All table lookup functions now use `none`.
 - varargs: `fn foo(bar int, params ...string) {`.
@@ -351,8 +779,8 @@ this backend.
 - `map.delete(key)`.
 - `libcurl` dependency was removed from the `http` module.
 - All function arguments are now immutable by default (previously they could be
-  modifed inside the function).
-- `http` functions now return optionals.
+  modified inside the function).
+- `http` functions now return options.
 - `sync.WaitGroup`.
 - `vweb` static files serving.
 - `crypto.rand` module.
@@ -446,8 +874,8 @@ this backend.
 ## V 0.1.12
 *4 Jul 2019*
 - V can finally compile itself on Windows (https://github.com/vlang/v#mingw-w64).
-- `os` module now uses optionals in all functions that return `File`.
-- Lots of bugs with optionals were fixed.
+- `os` module now uses options in all functions that return `File`.
+- Lots of bugs with options were fixed.
 - `println` was optimized. It no longer results in allocations.
     Now it also works correctly with all integer types.
 - Lots of `vfmt` fixes, it will be enabled tomorrow.

CONTRIBUTING.md

@@ -1,7 +1,7 @@
 ## Code Structure
 
 I tried to make the code of the compiler and vlib as simple and readable as
-possible.  One of V's goals is to be open to developers with different levels
+possible. One of V's goals is to be open to developers with different levels
 of experience in compiler development. Compilers don't need to be black boxes
 full of magic that only few people understand.
 
@@ -24,52 +24,55 @@ The architecture of the compiler is very simple and has three distinct steps:
 Parse/generate AST (`v.parser`) => Check types (`v.checker`)
 => Generate C/JavaScript/machine code (`v.gen`)
 
-
 The main files are:
 
 1. `cmd/v/v.v` The entry point.
 
-- V figures out the build mode.
-- Constructs the compiler object (`struct V`).
-- Creates a list of .v files that need to be parsed.
-- Creates a parser object for each file and runs `parse()` on them.
-- The correct backend is called (C, JS, native), and a binary is compiled.
+    - V figures out the build mode.
+    - Constructs the compiler object (`struct V`).
+    - Creates a list of .v files that need to be parsed.
+    - Creates a parser object for each file and runs `parse()` on them.
+    - The correct backend is called (C, JS, native), and a binary is compiled.
 
-2. `v/scanner` The scanner's job is to parse a list of characters and convert
-them to tokens.
+2. `vlib/v/scanner` The scanner's job is to parse a list of characters and convert
+   them to tokens.
 
-3. `v/token` This is simply a list of all tokens, their string values, and a
-couple of helper functions.
+3. `vlib/v/token` This is simply a list of all tokens, their string values, and a
+   couple of helper functions.
 
-4. `v/parser` The parser. It converts a list of tokens into an AST.
-In V, objects can be used before declaration, so unknown types are marked as
-unresolved. They are resolved later in the type checker.
+4. `vlib/v/parser` The parser. It converts a list of tokens into an AST.
+   In V, objects can be used before declaration, so unknown types are marked as
+   unresolved. They are resolved later in the type checker.
 
-5. `v/table` V creates one table object that is shared by all parsers. It
-contains all types, consts, and functions, as well as several helpers to search
-for objects by name, register new objects, modify types' fields, etc.
+5. `vlib/v/table` V creates one table object that is shared by all parsers. It
+   contains all types, consts, and functions, as well as several helpers to search
+   for objects by name, register new objects, modify types' fields, etc.
 
-6. `v/checker` Type checker and resolver. It processes the AST and makes sure
-the types are correct. Unresolved types are resolved, type information is added
-to the AST.
+6. `vlib/v/checker` Type checker and resolver. It processes the AST and makes sure
+   the types are correct. Unresolved types are resolved, type information is added
+   to the AST.
 
-7. `v/gen/c` C backend. It simply walks the AST and generates C code that can be
-compiled with Clang, GCC, Visual Studio, and TCC.
+7. `vlib/v/gen/c` C backend. It simply walks the AST and generates C code that can be
+   compiled with Clang, GCC, Visual Studio, and TCC.
 
-8. `json.v` defines the json code generation. This file will be removed once V
-supports comptime code generation, and it will be possible to do this using the
-language's tools.
+8. `vlib/v/gen/js` JavaScript backend. It simply walks the AST and generates JS code that can be
+   executed on the browser or in NodeJS/Deno.
 
-9. `v/gen/native` is the directory with all the machine code generation logic. It
-defines a set of functions that translate assembly instructions to machine code
-and build the binary from scratch byte by byte. It manually builds all headers,
-segments, sections, symtable, relocations, etc. Right now it only has basic
-support of the native platform (ELF, MACHO format).
+9. `vlib/v/gen/c/json.v` defines the json code generation. This file will be removed once V
+   supports comptime code generation, and it will be possible to do this using the
+   language's tools.
+
+10. `vlib/v/gen/native` is the directory with all the machine code generation logic. It
+    defines a set of functions that translate assembly instructions to machine code
+    and build the binary from scratch byte by byte. It manually builds all headers,
+    segments, sections, symtable, relocations, etc. Right now it only has basic
+    support of the native platform (ELF, MACHO format).
 
 The rest of the directories are vlib modules: `builtin/` (strings, arrays,
 maps), `time/`, `os/`, etc. Their documentation is pretty clear.
 
 ## Example Workflow for Contributing
+
 (provided by [@spytheman](https://github.com/spytheman))
 
 (If you don't already have a GitHub account, please create one. Your GitHub
@@ -77,37 +80,40 @@ username will be referred to later as 'YOUR_GITHUB_USERNAME'. Change it
 accordingly in the steps below.)
 
 1. Fork https://github.com/vlang/v using GitHub's interface to your own account.
-Let's say that the forked repository is at
-`https://github.com/YOUR_GITHUB_USERNAME/v` .
+   Let's say that the forked repository is at
+   `https://github.com/YOUR_GITHUB_USERNAME/v` .
 2. Clone the main v repository https://github.com/vlang/v to a local folder on
-your computer, say named nv/ (`git clone https://github.com/vlang/v nv`)
+   your computer, say named nv/ (`git clone https://github.com/vlang/v nv`)
 3. `cd nv`
 4. `git remote add pullrequest https://github.com/YOUR_GITHUB_USERNAME/v`
-NB: the remote named `pullrequest` should point to YOUR own forked repo, not the
-main v repository! After this, your local cloned repository is prepared for
-making pullrequests, and you can just do normal git operations such as:
-`git pull` `git status` and so on.
+
+   Note: The remote named `pullrequest` should point to YOUR own forked repo, not the
+   main v repository! After this, your local cloned repository is prepared for
+   making pull requests, and you can just do normal git operations such as:
+   `git pull` `git status` and so on.
 
 5. When finished with a feature/bugfix/change, you can:
 `git checkout -b fix_alabala`
-6. `git push pullrequest`  # (NOTE: the `pullrequest` remote was setup on step 4)
+   - Don't forget to keep formatting standards, run `v fmt -w YOUR_MODIFIED_FILES` before committing
+6. `git push pullrequest` Note: The `pullrequest` remote was setup on step 4
+
 7. On GitHub's web interface, go to: https://github.com/vlang/v/pulls
 
    Here the UI shows a dialog with a button to make a new pull request based on
    the new pushed branch.
    (Example dialog: https://url4e.com/gyazo/images/364edc04.png)
 
-8. After making your pullrequest (aka, PR), you can continue to work on the
-branch `fix_alabala` ... just do again `git push pullrequest` when you have more
-commits.
+8. After making your pull request (aka, PR), you can continue to work on the
+   branch `fix_alabala` ... just do again `git push pullrequest` when you have more
+   commits.
 
 9. If there are merge conflicts, or a branch lags too much behind V's master,
-you can do the following:
+   you can do the following:
 
-   1. `git pull --rebase origin master` # solve conflicts and do
-   `git rebase --continue`
-   2. `git push pullrequest -f` # this will overwrite your current remote branch
-   with the updated version of your changes.
+    1. `git pull --rebase origin master` # solve conflicts and do
+       `git rebase --continue`
+    2. `git push pullrequest -f` # this will overwrite your current remote branch
+       with the updated version of your changes.
 
 The point of doing the above steps, is to never directly push to the main V
 repository, *only to your own fork*. Since your local `master` branch tracks the
@@ -116,7 +122,8 @@ main V repository's master, then `git checkout master`, as well as
 (these are actually used by `v up`) and git can always do it cleanly.
 
 Git is very flexible, so there are other ways to accomplish the same thing.
-See the [GitHub flow](https://guides.github.com/introduction/git-handbook/#github), for more information.
+See the [GitHub flow](https://guides.github.com/introduction/git-handbook/#github), for more
+information.
 
 ## Using Github's hub CLI tool
 
@@ -125,9 +132,11 @@ You can download the `hub` tool from https://hub.github.com/ . Using
 to make PRs. Most remote operations can be done through the `hub` CLI
 command.
 
-NB: You still need to have a GitHub account.
+> **Note**
+> You still need to have a GitHub account.
 
 ### Preparation:
+
 (steps 1..3 need to be done just *once*):
 
 1. `hub clone vlang/v my_v`
@@ -135,13 +144,14 @@ NB: You still need to have a GitHub account.
 3. `hub fork --remote-name pullrequest`
 
 4. `git checkout -b my_cool_feature` # Step 4 is better done *once per each new
-feature/bugfix* that you make.
+   feature/bugfix* that you make.
 
 ### Improve V by making commits:
 
 5. `git commit -am "math: add a new function copysign"`
 
 ### Testing your commits locally:
+
 You can test locally whether your changes have not broken something by
 running: `v test-all`. See `TESTS.md` for more details.
 
@@ -150,6 +160,7 @@ running: `v test-all`. See `TESTS.md` for more details.
 6. `git push pullrequest`
 
 ### Making a PR with `hub`:
+
 (so that your changes can be merged to the main V repository)
 
 7. `hub pull-request`
@@ -159,6 +170,7 @@ Optionally, you can track the status of your PR CI tests with:
 8. `hub ci-status --verbose`
 
 ### Fixing failing tests:
+
 If everything is OK, after 5-10 minutes, the CI tests should pass for
 all platforms. If not, visit the URLs for the failing CI jobs, see
 which tests have failed and then fix them by making more changes. Just use
@@ -181,22 +193,22 @@ not the program, so do for example: `v -d time_parsing cmd/v` or
 Some flags can make the compiler very verbose, so it is recommended
 to create a copy of the compiler rather than replacing it with `v self`.
 
-| Flag | Usage |
-|------|-------|
-| `debugscanner` | Prints debug information during the scanning phase |
-| `debug_codegen` | Prints automatically generated V code during the scanning phase |
-| `debug_interface_table` | Prints generated interfaces during C generation |
-| `debug_interface_type_implements` | Prints debug information when checking that a type implements in interface |
-| `debug_embed_file_in_prod` | Prints debug information about the embedded files with `$embed_file('somefile')` |
-| `print_vweb_template_expansions` | Prints vweb compiled HTML files |
-| `time_checking` | Prints the time spent checking files and other related information |
-| `time_parsing` | Prints the time spent parsing files and other related information |
-| `trace_autofree` | Prints details about how/when -autofree puts free() calls |
-| `trace_autostr` | Prints details about `.str()` method auto-generated by the compiler during C generation |
-| `trace_ccoptions` | Prints options passed down to the C compiler |
-| `trace_checker` | Prints details about the statements being checked |
-| `trace_gen` | Prints strings written to the generated C file. Beware, this flag is very verbose |
-| `trace_parser` | Prints details about parsed statements and expressions |
-| `trace_thirdparty_obj_files` | Prints details about built thirdparty obj files |
-| `trace_usecache` | Prints details when -usecache is used |
-| `trace_embed_file` | Prints details when $embed_file is used |
+| Flag                              | Usage                                                                                                               |
+|-----------------------------------|---------------------------------------------------------------------------------------------------------------------|
+| `debugscanner`                    | Prints debug information during the scanning phase                                                                  |
+| `debug_codegen`                   | Prints automatically generated V code during the scanning phase                                                     |
+| `debug_interface_table`           | Prints generated interfaces during C generation                                                                     |
+| `debug_interface_type_implements` | Prints debug information when checking that a type implements in interface                                          |
+| `print_vweb_template_expansions`  | Prints vweb compiled HTML files                                                                                     |
+| `time_checking`                   | Prints the time spent checking files and other related information                                                  |
+| `time_parsing`                    | Prints the time spent parsing files and other related information                                                   |
+| `trace_autofree`                  | Prints details about how/when -autofree puts free() calls                                                           |
+| `trace_autostr`                   | Prints details about `.str()` method auto-generated by the compiler during C generation                             |
+| `trace_ccoptions`                 | Prints options passed down to the C compiler                                                                        |
+| `trace_checker`                   | Prints details about the statements being checked                                                                   |
+| `trace_gen`                       | Prints strings written to the generated C file. Beware, this flag is very verbose                                   |
+| `trace_parser`                    | Prints details about parsed statements and expressions                                                              |
+| `trace_thirdparty_obj_files`      | Prints details about built thirdparty obj files                                                                     |
+| `trace_usecache`                  | Prints details when -usecache is used                                                                               |
+| `trace_embed_file`                | Prints details when $embed_file is used                                                                             |
+| `embed_only_metadata`             | Embed only the metadata for the file(s) with `$embed_file('somefile')`; faster; for development, *not* distribution |

Dockerfile

@@ -7,7 +7,7 @@ WORKDIR /opt/vlang
 ARG USE_LOCAL
 
 RUN apt-get update && \
-    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends gcc clang make git && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends gcc clang make git binutils && \
     apt-get clean && rm -rf /var/cache/apt/archives/* && \
     rm -rf /var/lib/apt/lists/*
 

Dockerfile.alpine

@@ -12,11 +12,14 @@ RUN mkdir -p /opt/vlang && ln -s /opt/vlang/v /usr/bin/v
 
 ARG USE_LOCAL
 
+## libexecinfo is needed for the bundled tcc
 RUN apk --no-cache add \
   git make upx gcc bash \
-  musl-dev \
+  musl-dev libc-dev \
   openssl-dev sqlite-dev \
-  libx11-dev glfw-dev freetype-dev
+  libx11-dev glfw-dev freetype-dev \
+  libexecinfo-dev libexecinfo-static \
+  libc6-compat gcompat binutils
 
 ## RUN apk --no-cache add --virtual sdl2deps sdl2-dev sdl2_ttf-dev sdl2_mixer-dev sdl2_image-dev
 COPY . /vlang-local

Dockerfile.cross

@@ -1,10 +1,10 @@
 FROM mstorsjo/llvm-mingw
 
-LABEL maintainer="Vitaly Takmazov <vitalyster@gmail.com>"
+LABEL maintainer="Delyan Angelov <delian66@gmail.com>"
 COPY . .
 RUN make
 RUN ./v -os windows -o v.c cmd/v
-RUN x86_64-w64-mingw32-gcc v.c -std=c99 -I ./thirdparty/stdatomic/win -w -municode -o v.exe
+RUN x86_64-w64-mingw32-gcc v.c -std=c99 -w -municode -o v.exe
 RUN file v.exe
 
 CMD [ "bash" ]

GNUmakefile

@@ -4,16 +4,19 @@ LDFLAGS ?=
 TMPDIR ?= /tmp
 VROOT  ?= .
 VC     ?= ./vc
-V      ?= ./v
+VEXE   ?= ./v
 VCREPO ?= https://github.com/vlang/vc
 TCCREPO ?= https://github.com/vlang/tccbin
+LEGACYREPO ?= https://github.com/macports/macports-legacy-support
 
 VCFILE := v.c
 TMPTCC := $(VROOT)/thirdparty/tcc
+LEGACYLIBS := $(VROOT)/thirdparty/legacy
+TMPLEGACY := $(LEGACYLIBS)/source
 TCCOS := unknown
 TCCARCH := unknown
 GITCLEANPULL := git clean -xf && git pull --quiet
-GITFASTCLONE := git clone --depth 1 --quiet --single-branch
+GITFASTCLONE := git clone --filter=blob:none --quiet
 
 #### Platform detections and overrides:
 _SYS := $(shell uname 2>/dev/null || echo Unknown)
@@ -22,17 +25,23 @@ _SYS := $(patsubst MINGW%,MinGW,$(_SYS))
 
 ifneq ($(filter $(_SYS),MSYS MinGW),)
 WIN32 := 1
-V:=./v.exe
+VEXE := ./v.exe
 endif
 
 ifeq ($(_SYS),Linux)
 LINUX := 1
 TCCOS := linux
+ifneq ($(shell ldd /bin/ls | grep musl),)
+TCCOS := linuxmusl
+endif
 endif
 
 ifeq ($(_SYS),Darwin)
 MAC := 1
 TCCOS := macos
+ifeq ($(shell expr $(shell uname -r | cut -d. -f1) \<= 15), 1)
+LEGACY := 1
+endif
 endif
 
 ifeq ($(_SYS),FreeBSD)
@@ -45,6 +54,11 @@ TCCOS := netbsd
 LDFLAGS += -lexecinfo
 endif
 
+ifeq ($(_SYS),OpenBSD)
+TCCOS := openbsd
+LDFLAGS += -lexecinfo
+endif
+
 ifdef ANDROID_ROOT
 ANDROID := 1
 undefine LINUX
@@ -76,33 +90,42 @@ endif
 endif
 endif
 
-.PHONY: all clean fresh_vc fresh_tcc check_for_working_tcc
+.PHONY: all clean rebuild check fresh_vc fresh_tcc fresh_legacy check_for_working_tcc
 
 ifdef prod
 VFLAGS+=-prod
 endif
 
-all: latest_vc latest_tcc
+all: latest_vc latest_tcc latest_legacy
 ifdef WIN32
-	$(CC) $(CFLAGS) -std=c99 -municode -w -I ./thirdparty/stdatomic/nix -o v1.exe $(VC)/$(VCFILE) $(LDFLAGS)
+	$(CC) $(CFLAGS) -std=c99 -municode -w -o v1.exe $(VC)/$(VCFILE) $(LDFLAGS)
 	v1.exe -no-parallel -o v2.exe $(VFLAGS) cmd/v
-	v2.exe -o $(V) $(VFLAGS) cmd/v
+	v2.exe -o $(VEXE) $(VFLAGS) cmd/v
 	del v1.exe
 	del v2.exe
 else
-	$(CC) $(CFLAGS) -std=gnu99 -w -I ./thirdparty/stdatomic/nix -o v1.exe $(VC)/$(VCFILE) -lm -lpthread $(LDFLAGS)
+ifdef LEGACY
+	$(MAKE) -C $(TMPLEGACY)
+	$(MAKE) -C $(TMPLEGACY) PREFIX=$(realpath $(LEGACYLIBS)) CFLAGS=$(CFLAGS) LDFLAGS=$(LDFLAGS) install
+	rm -rf $(TMPLEGACY)
+	$(eval override LDFLAGS+=-L$(realpath $(LEGACYLIBS))/lib -lMacportsLegacySupport)
+endif
+	$(CC) $(CFLAGS) -std=gnu99 -w -o v1.exe $(VC)/$(VCFILE) -lm -lpthread $(LDFLAGS)
 	./v1.exe -no-parallel -o v2.exe $(VFLAGS) cmd/v
-	./v2.exe -o $(V) $(VFLAGS) cmd/v
+	./v2.exe -nocache -o $(VEXE) $(VFLAGS) cmd/v
 	rm -rf v1.exe v2.exe
 endif
-	@$(V) run cmd/tools/detect_tcc.v
+	@$(VEXE) run cmd/tools/detect_tcc.v
 	@echo "V has been successfully built"
-	@$(V) -version
+	@$(VEXE) -version
 
 clean:
 	rm -rf $(TMPTCC)
+	rm -rf $(LEGACYLIBS)
 	rm -rf $(VC)
 
+rebuild: clean all
+
 ifndef local
 latest_vc: $(VC)/.git/config
 	cd $(VC) && $(GITCLEANPULL)
@@ -113,7 +136,7 @@ endif
 
 check_for_working_tcc:
 	@$(TMPTCC)/tcc.exe --version > /dev/null 2> /dev/null || echo "The executable '$(TMPTCC)/tcc.exe' does not work."
-	
+
 fresh_vc:
 	rm -rf $(VC)
 	$(GITFASTCLONE) $(VCREPO) $(VC)
@@ -145,22 +168,45 @@ else
 	@$(MAKE) --quiet check_for_working_tcc 2> /dev/null
 endif
 
+ifndef local
+latest_legacy: $(TMPLEGACY)/.git/config
+ifdef LEGACY
+	cd $(TMPLEGACY) && $(GITCLEANPULL)
+endif
+else
+latest_legacy:
+ifdef LEGACY
+	@echo "Using local legacysupport"
+endif
+endif
+
+fresh_legacy:
+	rm -rf $(LEGACYLIBS)
+	$(GITFASTCLONE) $(LEGACYREPO) $(TMPLEGACY)
+
 $(TMPTCC)/.git/config:
 	$(MAKE) fresh_tcc
 
 $(VC)/.git/config:
 	$(MAKE) fresh_vc
 
+$(TMPLEGACY)/.git/config:
+ifdef LEGACY
+	$(MAKE) fresh_legacy
+endif
+
 asan:
 	$(MAKE) all CFLAGS='-fsanitize=address,undefined'
 
 selfcompile:
-	$(V) -cg -o v cmd/v
+	$(VEXE) -cg -o v cmd/v
 
 selfcompile-static:
-	$(V) -cg -cflags '--static' -o v-static cmd/v
+	$(VEXE) -cg -cflags '--static' -o v-static cmd/v
 
 ### NB: Please keep this Makefile and make.bat simple.
 install:
 	@echo 'Please use `sudo ./v symlink` instead.'
 
+check:
+	$(VEXE) test-all

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2021 Alexander Medvednikov
+Copyright (c) 2019-2023 Alexander Medvednikov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,12 +1,22 @@
 CC ?= cc
 VFLAGS ?=
+CFLAGS ?=
+LDFLAGS ?=
 
-all:
-	rm -rf vc/
-	git clone --depth 1 --quiet https://github.com/vlang/vc
-	$(CC) -std=gnu11 -w -I ./thirdparty/stdatomic/nix -o v1 vc/v.c -lm -lexecinfo -lpthread
+.PHONY: all check download_vc v
+
+all: download_vc v
+
+download_vc:
+	if [ -f vc/v.c ] ; then git -C vc/ pull; else git clone --filter=blob:none https://github.com/vlang/vc vc/; fi
+
+v:
+	$(CC) $(CFLAGS) -std=gnu11 -w -o v1 vc/v.c -lm -lexecinfo -lpthread $(LDFLAGS)
 	./v1 -no-parallel -o v2 $(VFLAGS) cmd/v
 	./v2 -o v $(VFLAGS) cmd/v
-	rm -rf v1 v2 vc/
+	rm -rf v1 v2
 	@echo "V has been successfully built"
 	./v run ./cmd/tools/detect_tcc.v
+
+check:
+	./v test-all

README.md

@@ -1,39 +1,37 @@
-<div align="center">
+<div align="center" style="display:grid;place-items:center;">
 <p>
-    <img width="80" src="https://raw.githubusercontent.com/vlang/v-logo/master/dist/v-logo.svg?sanitize=true">
+    <a href="https://vlang.io/" target="_blank"><img width="80" src="https://raw.githubusercontent.com/vlang/v-logo/master/dist/v-logo.svg?sanitize=true" alt="V logo"></a>
 </p>
 <h1>The V Programming Language</h1>
 
-[vlang.io](https://vlang.io) |
-[Docs](https://github.com/vlang/v/blob/master/doc/docs.md) |
-[Changelog](https://github.com/vlang/v/blob/master/CHANGELOG.md) |
-[Speed](https://fast.vlang.io/) |
-[Contributing & compiler design](https://github.com/vlang/v/blob/master/CONTRIBUTING.md)
-
+[vlang.io](https://vlang.io) | [Docs](https://github.com/vlang/v/blob/master/doc/docs.md) | [Changelog](https://github.com/vlang/v/blob/master/CHANGELOG.md) | [Speed](https://fast.vlang.io/) | [Contributing & compiler design](https://github.com/vlang/v/blob/master/CONTRIBUTING.md)
 </div>
-<div align="center">
-
+<div align="center" style="display:grid;place-items:center;">
 <!--
 [![Build Status][WorkflowBadge]][WorkflowUrl]
 -->
+
 [![Sponsor][SponsorBadge]][SponsorUrl]
 [![Patreon][PatreonBadge]][PatreonUrl]
 [![Discord][DiscordBadge]][DiscordUrl]
-[![Twitter][TwitterUrl]][TwitterBadge]
-
+[![Twitter][TwitterBadge]][TwitterUrl]
+[![Modules][ModulesBadge]][ModulesUrl]
 </div>
 
 ## Key Features of V
 
-- Simplicity: the language can be learned in less than an hour
+- Simplicity: the language can be learned over the course of a weekend
 - Fast compilation: ≈110k loc/s with a Clang backend,
-    ≈1 million loc/s with native and tcc backends *(Intel i5-7500, SSD, no optimization)* ([demo video](https://www.youtube.com/watch?v=pvP6wmcl_Sc))
+  ≈500k loc/s with native and tcc backends *(Intel i5-7500, SSD, no
+  optimization)* ([demo video](https://www.youtube.com/watch?v=pvP6wmcl_Sc))
 - Easy to develop: V compiles itself in less than a second
 - Performance: as fast as C (V's main backend compiles to human-readable C)
-- Safety: no null, no globals, no undefined behavior, immutability by default
-- C to V translation
+- Safety: no null, no globals, no undefined behavior (wip), immutability by default
+- C to V translation ([Translating DOOM demo video](https://www.youtube.com/watch?v=6oXrz3oRoEg))
 - Hot code reloading
-- [Innovative memory management](https://vlang.io/#memory) ([demo video](https://www.youtube.com/watch?v=gmB8ea8uLsM))
+- [Flexible memory management](https://vlang.io/#memory). GC by default, manual via `v -gc none`,
+  arena allocation via `v -prealloc`, autofree via `v -autofree`
+  ([autofree demo video](https://www.youtube.com/watch?v=gmB8ea8uLsM)).
 - [Cross-platform UI library](https://github.com/vlang/ui)
 - Built-in graphics library
 - Easy cross-compilation
@@ -62,20 +60,32 @@ language, very similar to the way it is right now.
 
 ## Installing V from source
 
-### Linux, macOS, Windows, *BSD, Solaris, WSL, Android, Raspbian
+--> **_(this is the preferred method)_**
+
+### Linux, macOS, Windows, *BSD, Solaris, WSL, etc.
+
+Usually, installing V is quite simple if you have an environment that already has a
+functional `git` installation.
+
+To get started, simply try to execute the following in your terminal/shell:
 
 ```bash
 git clone https://github.com/vlang/v
 cd v
 make
+# HINT: Using Windows? run make.bat in a cmd shell, or ./make.bat in PowerShell
 ```
 
-That's it! Now you have a V executable at `[path to V repo]/v`.
+That should be it and you should find your V executable at `[path to V repo]/v`.
 `[path to V repo]` can be anywhere.
 
-(On Windows `make` means running `make.bat`, so make sure you use `cmd.exe`)
+(As in the hint above, on Windows `make` means running `make.bat`.)
 
-Now you can try `./v run examples/hello_world.v` (`v.exe` on Windows).
+Now you can try `./v run examples/hello_world.v` (or `v run examples/hello_world.v` in cmd shell).
+
+* *Trouble? Please see the note above and link to
+  [Installation Issues](https://github.com/vlang/v/discussions/categories/installation-issues)
+  for help.*
 
 V is constantly being updated. To update V, simply run:
 
@@ -83,10 +93,25 @@ V is constantly being updated. To update V, simply run:
 v up
 ```
 
+> **Note**
+> If you run into any trouble, or you have a different operating
+> system or Linux distribution that doesn't install or work immediately, please see
+> [Installation Issues](https://github.com/vlang/v/discussions/categories/installation-issues)
+> and search for your OS and problem.
+>
+> If you can't find your problem, please add it to an existing discussion if one exists for
+> your OS, or create a new one if a main discussion doesn't yet exist for your OS.
+
 ### C compiler
 
-It's recommended to use Clang, GCC, or Visual Studio.
-If you are doing development, you most likely already have one of those installed.
+The [Tiny C Compiler (tcc)](https://repo.or.cz/w/tinycc.git) is downloaded for you by `make` if
+there is a compatible version for your system, and installed under the V `thirdparty` directory.
+
+This compiler is very fast, but does almost no optimizations. It is best for development builds.
+
+For production builds (using the `-prod` option to V), it's recommended to use clang, gcc, or
+Microsoft Visual C++. If you are doing development, you most likely already have one of those
+installed.
 
 Otherwise, follow these instructions:
 
@@ -94,15 +119,12 @@ Otherwise, follow these instructions:
 
 - [Installing a C compiler on Windows](https://github.com/vlang/v/wiki/Installing-a-C-compiler-on-Windows)
 
-However, if none is found when running `make` on Linux or Windows,
-TCC is downloaded as the default C backend.
-It's very lightweight (several MB) so this shouldn't take too long.
-
 ### Symlinking
 
-NB: it is *highly recommended*, that you put V on your PATH. That saves
-you the effort to type in the full path to your v executable every time.
-V provides a convenience `v symlink` command to do that more easily.
+> **Note**
+> It is *highly recommended*, that you put V on your PATH. That saves
+> you the effort to type in the full path to your v executable every time.
+> V provides a convenience `v symlink` command to do that more easily.
 
 On Unix systems, it creates a `/usr/local/bin/v` symlink to your
 executable. To do that, run:
@@ -111,23 +133,38 @@ executable. To do that, run:
 sudo ./v symlink
 ```
 
-On Windows, start a new shell with administrative privileges, for
-example by <kbd>Windows Key</kbd>, then type `cmd.exe`, right-click on its menu
-entry, and choose `Run as administrator`. In the new administrative
-shell, cd to the path, where you have compiled v.exe, then type:
+On Windows, start a new shell with administrative privileges, for example by pressing the
+<kbd>Windows Key</kbd>, then type `cmd.exe`, right-click on its menu entry, and choose `Run as
+administrator`. In the new administrative shell, cd to the path where you have compiled V, then
+type:
 
 ```bat
-.\v.exe symlink
+v symlink
 ```
 
-That will make V available everywhere, by adding it to your PATH.
-Please restart your shell/editor after that, so that it can pick
-the new PATH variable.
+(or `./v symlink` in PowerShell)
 
-NB: there is no need to run `v symlink` more than once - v will
-continue to be available, even after `v up`, restarts, and so on.
-You only need to run it again, if you decide to move the V repo
-folder somewhere else.
+That will make V available everywhere, by adding it to your PATH. Please restart your
+shell/editor after that, so that it can pick up the new PATH variable.
+
+> **Note**
+> There is no need to run `v symlink` more than once - v will still be available, even after
+> `v up`, restarts, and so on.  You only need to run it again if you decide to move the V repo
+> folder somewhere else.
+
+### Void Linux
+
+<details><summary>Expand Void Linux instructions</summary>
+
+```bash
+# xbps-install -Su base-devel
+# xbps-install libatomic-devel
+$ git clone https://github.com/vlang/v
+$ cd v
+$ make
+```
+
+</details>
 
 ### Docker
 
@@ -151,17 +188,55 @@ docker run --rm -it vlang:latest
 
 </details>
 
-### Testing and running the examples
+### Termux/Android
+
+On Termux, V needs some packages preinstalled - a working C compiler, also `libexecinfo`,
+`libgc` and `libgc-static`. After installing them, you can use the same script, like on
+Linux/macos:
+
+```bash
+pkg install clang libexecinfo libgc libgc-static make git
+git clone https://github.com/vlang/v
+cd v
+make
+```
+
+## Installing editor/IDE plugin
+
+V has plugins for many editors:
+
+- [VS Code plugin](https://github.com/vlang/vscode-vlang)
+- [JetBrains IDE plugin](https://plugins.jetbrains.com/plugin/20287-vlang/docs/quick-start-guide.html)
+- [Vim plugins](https://github.com/vlang/awesome-v#vim)
+- [Emacs plugins](https://github.com/vlang/awesome-v#emacs)
+- [Sublime Text 3 plugins](https://github.com/vlang/awesome-v#sublime-text-3)
+- [Atom plugins](https://github.com/vlang/awesome-v#atom)
+
+### IntelliSense
+
+V has a Language Server:
+[VLS](https://github.com/vlang/vls).
+The VS Code plugin provides built-in support for VLS.
+
+> **Note**
+> 
+> VLS may be unstable at the moment.
+> If you encounter any problem, please create a new
+> [issue](https://github.com/vlang/vls/issues).
+
+The plugin for JetBrains IDE (IntelliJ, CLion, GoLand, etc) at the moment is
+the best choice if you want a great V development experience.
+You can see all its features in
+[its documentation](https://plugins.jetbrains.com/plugin/20287-vlang/docs/syntax-highlighting.html).
+
+## Testing and running the examples
 
 Make sure V can compile itself:
 
 ```bash
-v self
-```
-
-```bash
+$ v self
 $ v
-V 0.2.x
+V 0.3.x
 Use Ctrl-C or `exit` to exit
 
 >>> println('hello world')
@@ -179,47 +254,52 @@ v run news_fetcher.v
 v run tetris/tetris.v
 ```
 
-<img src='https://raw.githubusercontent.com/vlang/v/master/examples/tetris/screenshot.png' width=300>
+<img src='https://raw.githubusercontent.com/vlang/v/master/examples/tetris/screenshot.png' width=300 alt='tetris screenshot'>
 
-NB: In order to build Tetris or 2048 (or anything else using `sokol` or  `gg` graphics modules)
-on some Linux systems, you need to install `libxi-dev` and `libxcursor-dev` .
+In order to build Tetris or 2048 (or anything else using `sokol` or `gg` graphics modules),
+you will need additional development libraries for your system.
+
+| System              | Installation method                                                                                |
+|---------------------|----------------------------------------------------------------------------------------------------|
+| Debian/Ubuntu based | `sudo apt install libxi-dev libxcursor-dev libgl-dev`                                                        |
+| Fedora/RH/CentOS    | `sudo dnf install libXcursor-devel libXi-devel libX11-devel libglvnd-devel`                        |
+| NixOS               | add `xorg.libX11.dev xorg.libXcursor.dev xorg.libXi.dev libGL.dev` to `environment.systemPackages` |
 
 ## V net.http, net.websocket, `v install`
-If you plan to use the net.http module, or the net.websocket module, you also need to install
-OpenSSL on non-Windows systems:
 
-```bash
-macOS:
-brew install openssl
+The net.http module, the net.websocket module, and the `v install` command may all use SSL.
+V comes with a version of mbedtls, which should work on all systems. If you find a need to
+use OpenSSL instead, you will need to make sure that it is installed on your system, then
+use the `-d use_openssl` switch when you compile.
 
-Debian/Ubuntu:
-sudo apt install libssl-dev
+To install OpenSSL on non-Windows systems:
 
-Arch/Manjaro:
-openssl is installed by default
+| System              | Installation command             |
+|---------------------|----------------------------------|
+| macOS               | `brew install openssl`           |
+| Debian/Ubuntu based | `sudo apt install libssl-dev`    |
+| Arch/Manjaro        | openssl is installed by default  |
+| Fedora/CentOS/RH    | `sudo dnf install openssl-devel` |
 
-Fedora:
-sudo dnf install openssl-devel
-```
+On Windows, OpenSSL is simply hard to get working correctly. The instructions
+[here](https://tecadmin.net/install-openssl-on-windows/) may (or may not) help.
 
 ## V sync
+
 V's `sync` module and channel implementation uses libatomic.
 It is most likely already installed on your system, but if not,
 you can install it, by doing the following:
-```bash
-MacOS: already installed
 
-Debian/Ubuntu:
-sudo apt install libatomic1
-
-Fedora/CentOS/RH:
-sudo dnf install libatomic-static
-```
+| System              | Installation command                |
+|---------------------|-------------------------------------|
+| macOS               | already installed                   |
+| Debian/Ubuntu based | `sudo apt install libatomic1`       |
+| Fedora/CentOS/RH    | `sudo dnf install libatomic-static` |
 
 ## V UI
 
 <a href="https://github.com/vlang/ui">
-<img src='https://raw.githubusercontent.com/vlang/ui/master/examples/screenshot.png' width=712>
+<img src='https://raw.githubusercontent.com/vlang/ui/master/examples/screenshot.png' width=712 alt='V UI example screenshot'>
 </a>
 
 https://github.com/vlang/ui
@@ -254,17 +334,17 @@ With V's `vab` tool, building V UI and graphical apps for Android can become as
 ```
 
 [https://github.com/vlang/vab](https://github.com/vlang/vab).
-
-<img src="https://user-images.githubusercontent.com/768942/107622846-c13f3900-6c58-11eb-8a66-55db12979b73.png">
+<img src="https://user-images.githubusercontent.com/768942/107622846-c13f3900-6c58-11eb-8a66-55db12979b73.png" alt="vab examples screenshot">
 
 ## Developing web applications
 
-Check out the [Building a simple web blog](https://github.com/vlang/v/blob/master/tutorials/building_a_simple_web_blog_with_vweb/README.md)
+Check out the
+[Building a simple web blog](https://github.com/vlang/v/blob/master/tutorials/building_a_simple_web_blog_with_vweb/README.md)
 tutorial and Gitly, a light and fast alternative to GitHub/GitLab:
 
 https://github.com/vlang/gitly
 
-<img src="https://user-images.githubusercontent.com/687996/85933714-b195fe80-b8da-11ea-9ddd-09cadc2103e4.png">
+<img src="https://user-images.githubusercontent.com/687996/85933714-b195fe80-b8da-11ea-9ddd-09cadc2103e4.png" alt="gitly screenshot">
 
 ## Vinix, an OS/kernel written in V
 
@@ -273,20 +353,35 @@ Vinix is an OS/kernel that already runs bash, GCC, V, and nano.
 
 https://github.com/vlang/vinix
 
-<img src="https://github.com/vlang/vinix/raw/main/screenshot.png?raw=true">
+<img src="https://github.com/vlang/vinix/blob/main/screenshot0.png?raw=true" alt="vinix screenshot 1">
+<img src="https://github.com/vlang/vinix/blob/main/screenshot1.png?raw=true" alt="vinix screenshot 2">
+
+## Acknowledgement
+
+V thanks Fabrice Bellard for his original work on the
+[TCC - Tiny C Compiler](https://bellard.org/tcc/).
+Note the TCC website is old; the current TCC repository can be found
+[here](https://repo.or.cz/w/tinycc.git).
+V utilizes pre-built TCC binaries located at
+[https://github.com/vlang/tccbin/](https://github.com/vlang/tccbin/).
 
 ## Troubleshooting
 
-Please see the [Troubleshooting](https://github.com/vlang/v/wiki/Troubleshooting) section on our [wiki page](https://github.com/vlang/v/wiki)
+Please see the
+[Troubleshooting](https://github.com/vlang/v/wiki/Troubleshooting)
+section on our
+[wiki page](https://github.com/vlang/v/wiki).
 
 [WorkflowBadge]: https://github.com/vlang/v/workflows/CI/badge.svg
 [DiscordBadge]: https://img.shields.io/discord/592103645835821068?label=Discord&logo=discord&logoColor=white
-[PatreonBadge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dvlang%26type%3Dpledges
+[PatreonBadge]: https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dvlang%26type%3Dpatrons&style=flat
 [SponsorBadge]: https://camo.githubusercontent.com/da8bc40db5ed31e4b12660245535b5db67aa03ce/68747470733a2f2f696d672e736869656c64732e696f2f7374617469632f76313f6c6162656c3d53706f6e736f72266d6573736167653d254532253944254134266c6f676f3d476974487562
-[TwitterBadge]: https://twitter.com/v_language
+[TwitterBadge]: https://img.shields.io/badge/follow-%40v_language-1DA1F2?logo=twitter&style=flat&logoColor=white&color=1da1f2
+[ModulesBadge]: https://img.shields.io/badge/modules-reference-027d9c?logo=v&logoColor=white&logoWidth=10
 
 [WorkflowUrl]: https://github.com/vlang/v/commits/master
 [DiscordUrl]: https://discord.gg/vlang
 [PatreonUrl]: https://patreon.com/vlang
 [SponsorUrl]: https://github.com/sponsors/medvednikov
-[TwitterUrl]: https://img.shields.io/twitter/follow/v_language.svg?style=flatl&label=Follow&logo=twitter&logoColor=white&color=1da1f2
+[TwitterUrl]: https://twitter.com/v_language
+[ModulesUrl]: https://modules.vlang.io

ROADMAP.md

@@ -1,34 +1,67 @@
-## [Version 0.3](https://github.com/vlang/v/projects/5)
-- [ ] [make `-autofree` the default](https://github.com/vlang/v/issues/6989)
-- [x] [gc option]
-- [ ] [coroutines](https://github.com/vlang/v/issues/561)
+## [Version 0.3]
+- [x] gc option
 - [x] channels
 - [x] lock{}
 - [x] thread safe arrays
-- [ ] [thread safe maps](https://github.com/vlang/v/issues/6992)
-- [ ] [C2V translator](https://github.com/vlang/v/issues/6985)
-- [ ] doom.v
 - [x] rune type
 - [x] replace `ustring` with `[]rune`
 - [x] fix `byte.str()`
 - [x] maps with non-string keys
 - [x] iOS/Android support
-- [ ] parallel parser
-- [ ] parallel checker
 - [x] parallel cgen
-- [ ] parallel C compilation
-- [ ] `recover()` from panics
 - [x] IO streams
 - [x] struct embedding
 - [x] interface embedding
 - [x] interfaces: allow struct fields (not just methods)
-- [ ] vfmt: fix common errors automatically (make vars mutable and vice versa, add missing imports)
-- [ ] method expressions with an explicit receiver as the first argument
 - [x] short generics syntax (`foo(5)` instead of `foo<int>(5)`)
-- [ ] fix all remaining generics issues
-- [ ] merge v.c and v_win.c
 - [x] more advanced errors, not just `error('message')`
-- [ ] VLS for autocomplete, refactoring, go to definition etc
-- [ ] Recursive structs via optionals: `struct Node { next ?Node }`
-- [ ] Remove `foo = 0` for `&Foo`
+
+## [Version 0.4]
+
+- [x] [Coroutines](https://github.com/vlang/v/discussions/11582)
+- [x] vfmt: add missing imports (like goimports)
+- [x] Recursive structs via options: `struct Node { next ?Node }`
+- [x] First class Option type
+- [x] Optional function struct fields
 - [ ] Handle function pointers safely, remove `if function == 0 {`
+- [x] Bundle OpenSSL like GC
+- [x] Anonymous structs
+- [x] Improve vweb: allow separation of logic via "controllers", lots of other fixes
+- [x] New VPM site
+
+## [Version 0.5]
+
+- [ ] [Thread safe maps](https://github.com/vlang/v/discussions/11729)
+- [ ] Parallel parser
+- [ ] Parallel checker
+- [ ] Parallel C compilation
+- [ ] `recover()` from panics
+- [ ] -usecache on by default
+- [ ] -skip-unused on by default
+- [ ] 64/32 bit int depending on arch (will remove array.len limitation on 64 bit systems)
+- [ ] `copy()` builtin function (e.g. for easier conversion from `[]Foo` to `[4]Foo`)
+
+## [Version 1.0]
+
+- [ ] Cross compilation of C
+- [ ] Big remaining bugs fixed
+- [ ] More powerful comptime
+- [ ] Constraits for generics
+- [ ] Coroutines on Windows
+- [ ] Autofree memory management option ready for production
+- [ ] C2V supporting entire C99 standard
+
+### Tooling
+
+- [ ] More stable VLS
+- [ ] Profiler improvements
+  - [ ] Basic interactive shell with search, sort, filter, etc.
+- [ ] VPM
+  - [x] New VPM site
+  - [ ] Package versioning
+- [ ] A better documentation platform
+
+### Web
+
+- [ ] Site that brings everything together in a single style
+- [ ] Interactive educational platform (learning to program for beginners)

TESTS.md

@@ -5,15 +5,16 @@ and before submitting PRs.
 
 Tip: use `v -cc tcc` when compiling tests, because TCC is much faster,
 compared to most other C compilers like clang/gcc/msvc. Most test commands
-will use the V compiler and the V tools many times, potentially 
+will use the V compiler and the V tools many times, potentially
 hundreds/thousands of times.
 
 ## `v test-all`
 
-Test and build *everything*. Usefull to verify *locally*, that the CI will
+Test and build *everything*. Useful to verify *locally*, that the CI will
 most likely pass. Slowest, but most comprehensive.
 
 It works, by running these in succession:
+
 * `v test-cleancode`
 * `v test-self`
 * `v test-fmt`
@@ -23,10 +24,12 @@ It works, by running these in succession:
 * `v install nedpals.args`
 
 # Details:
+
 In the `v` repo there are many tests. The main types are:
 
 ## `_test.v` tests - these are the normal V test files.
-All `test_` functions in these files, will be ran automatically by 
+
+All `test_` functions in these files, will be ran automatically by
 V's test framework.
 
 NB 1: You can run test files one by one, with:
@@ -44,22 +47,22 @@ recursively.
 `v -stats test folder` - same, but will also produce timing reports
 about how fast each test_ function in each _test.v file ran.
 
-
 ## `v test vlib/v/tests`:
 
 This folder contains _test.v files, testing the different features of the V
 compiler. Each of them will be compiled, and all the features in them have
 to work (verified by assertions).
 
-## `v vlib/v/tests/inout/compiler_test.v`
+## `v vlib/v/slow_tests/inout/compiler_test.v`
 
 This is a *test runner*, that checks whether the output of running a V program,
 matches an expected .out file. You can also check for code that does panic
 using this test runner - just paste the start of the `panic()` output in the
 corresponding .out file.
 
-NB: these tests, expect to find a pair of `.vv` and `.out` files, in the folder:
-vlib/v/tests/inout
+> **Note**
+> These tests, expect to find a pair of `.vv` and `.out` files, in the folder:
+> vlib/v/slow_tests/inout
 
 The test runner will run each `.vv` file, and will check that its output, matches
 the contents of the `.out` file with the same base name. This is particularly useful
@@ -77,11 +80,27 @@ Each `.c.must_have` file, consists of multiple lines. Each of these
 lines, *should* be present *at least once* in the output, when the .vv
 file is compiled with `-o -` .
 
-## `v vlib/v/tests/run_project_folders_test.v`
+## `v vlib/v/slow_tests/run_project_folders_test.v`
+
 This *test runner*, checks whether whole project folders, can be compiled, and run.
 
-NB: Each project in these folders, should finish with an exit code of 0,
-and it should output `OK` as its last stdout line.
+> **Note**
+> Each project in these folders, should finish with an exit code of 0,
+> and it should output `OK` as its last stdout line.
+
+## `v vlib/v/tests/known_errors/known_errors_test.v`
+
+This *test runner*, checks whether a known program, that was expected to compile,
+but did NOT, due to a buggy checker, parser or cgen, continues to fail.
+The negative programs are collected in the `vlib/v/tests/known_errors/testdata/` folder.
+Each of them should FAIL to compile, due to a known/confirmed compiler bug/limitation.
+
+The intended use of this, is for providing samples, that currently do NOT compile,
+but that a future compiler improvement WILL be able to compile, and to
+track, whether they were not fixed incidentally, due to an unrelated
+change/improvement. For example, code that triggers generating invalid C code can go here,
+and later when a bug is fixed, can be moved to a proper _test.v or .vv/.out pair, outside of
+the `vlib/v/tests/known_errors/testdata/` folder.
 
 ## Test building of actual V programs (examples, tools, V itself)
 
@@ -133,21 +152,23 @@ Run `vlib` module tests, *including* the compiler tests.
 ## `v vlib/v/compiler_errors_test.v`
 
 This runs tests for:
+
 * `vlib/v/scanner/tests/*.vv`
 * `vlib/v/checker/tests/*.vv`
 * `vlib/v/parser/tests/*.vv`
 
-NB: there are special folders, that compiler_errors_test.v will try to
-run/compile with specific options:
+> **Note**
+> There are special folders, that compiler_errors_test.v will try to
+> run/compile with specific options:
 
-vlib/v/checker/tests/globals_run/ - `-enable-globals run`; 
+vlib/v/checker/tests/globals_run/ - `-enable-globals run`;
 results stored in `.run.out` files, matching the .vv ones.
 
 NB 2: in case you need to modify many .out files, run *twice* in a row:
-`VAUTOFIX=1 ./v vlib/v/compiler_errors_test.v` 
+`VAUTOFIX=1 ./v vlib/v/compiler_errors_test.v`
 This will fail the first time, but it will record the new output for each
 .vv file, and store it into the corresponding .out file. The second run
-should be now successfull, and so you can inspect the difference, and 
+should be now successful, and so you can inspect the difference, and
 commit the new .out files with minimum manual effort.
 
 NB 3: To run only some of the tests, use:

cmd/tools/bench/wyhash.v

@@ -10,17 +10,17 @@ fn main() {
 	sample_size := 10000000
 	min_str_len := 20
 	max_str_len := 40
-	println('Generating $sample_size strings between $min_str_len - $max_str_len chars long...')
+	println('Generating ${sample_size} strings between ${min_str_len} - ${max_str_len} chars long...')
 	mut checksum := u64(0)
 	mut start_pos := 0
 	mut bgenerating := benchmark.start()
-	mut bytepile := []byte{}
+	mut bytepile := []u8{}
 	for _ in 0 .. sample_size * max_str_len {
-		bytepile << byte(rand.int_in_range(40, 125))
+		bytepile << u8(rand.int_in_range(40, 125) or { 40 })
 	}
 	mut str_lens := []int{}
 	for _ in 0 .. sample_size {
-		str_lens << rand.int_in_range(min_str_len, max_str_len)
+		str_lens << rand.int_in_range(min_str_len, max_str_len) or { min_str_len }
 	}
 	bgenerating.measure('generating strings')
 	println('Hashing each of the generated strings...')
@@ -30,7 +30,7 @@ fn main() {
 	checksum = 0
 	for len in str_lens {
 		end_pos := start_pos + len
-		checksum ^= wyhash.wyhash_c(unsafe { &byte(bytepile.data) + start_pos }, u64(len),
+		checksum ^= wyhash.wyhash_c(unsafe { &u8(bytepile.data) + start_pos }, u64(len),
 			1)
 		start_pos = end_pos
 	}

cmd/tools/builders/golang_builder.v

@@ -0,0 +1,7 @@
+module main
+
+import v.builder.golangbuilder
+
+fn main() {
+	golangbuilder.start()
+}

cmd/tools/builders/wasm_builder.v

@@ -0,0 +1,7 @@
+module main
+
+import v.builder.wasmbuilder
+
+fn main() {
+	wasmbuilder.start()
+}

cmd/tools/check_os_api_parity.v

@@ -40,10 +40,10 @@ mut:
 }
 
 fn main() {
-	vexe := pref.vexe_path()
+	vexe := os.real_path(os.getenv_opt('VEXE') or { @VEXE })
 	vroot := os.dir(vexe)
 	util.set_vroot_folder(vroot)
-	os.chdir(vroot) ?
+	os.chdir(vroot)!
 	cmd := diff.find_working_diff_command() or { '' }
 	mut app := App{
 		diff_cmd: cmd
@@ -52,7 +52,7 @@ fn main() {
 	}
 	for mname in app.modules {
 		if !app.is_verbose {
-			eprintln('Checking module: $mname ...')
+			eprintln('Checking module: ${mname} ...')
 		}
 		api_base := app.gen_api_for_module_in_os(mname, base_os)
 		for oname in os_names {
@@ -65,9 +65,9 @@ fn main() {
 	}
 	howmany := app.api_differences.len
 	if howmany > 0 {
-		eprintln(term.header('Found $howmany modules with different APIs', '='))
+		eprintln(term.header('Found ${howmany} modules with different APIs', '='))
 		for m in app.api_differences.keys() {
-			eprintln('Module: $m')
+			eprintln('Module: ${m}')
 		}
 		exit(1)
 	}
@@ -108,7 +108,7 @@ fn (app App) gen_api_for_module_in_os(mod_name string, os_name string) string {
 					fn_signature := s.stringify(b.table, mod_name, map[string]string{})
 					fn_mod := s.modname()
 					if fn_mod == mod_name {
-						fline := '$fn_mod: $fn_signature'
+						fline := '${fn_mod}: ${fn_signature}'
 						res << fline
 					}
 				}
@@ -122,7 +122,7 @@ fn (app App) gen_api_for_module_in_os(mod_name string, os_name string) string {
 fn (mut app App) compare_api(api_base string, api_os string, mod_name string, os_base string, os_target string) {
 	res := diff.color_compare_strings(app.diff_cmd, rand.ulid(), api_base, api_os)
 	if res.len > 0 {
-		summary := 'Different APIs found for module: `$mod_name`, between OS base: `$os_base` and OS: `$os_target`'
+		summary := 'Different APIs found for module: `${mod_name}`, between OS base: `${os_base}` and OS: `${os_target}`'
 		eprintln(term.header(summary, '-'))
 		eprintln(res)
 		eprintln(term.h_divider('-'))

cmd/tools/detect_tcc.v

@@ -4,12 +4,14 @@ fn main() {
 		exit(0)
 	}
 
-	println('
-NB: `tcc` was not used, so unless you install it yourself, your backend
+	$if !macos {
+		println('
+Note: `tcc` was not used, so unless you install it yourself, your backend
 C compiler will be `cc`, which is usually either `clang`, `gcc` or `msvc`.
 
 These C compilers, are several times slower at compiling C source code,
 compared to `tcc`. They do produce more optimised executables, but that
 is done at the cost of compilation speed.
 ')
+	}
 }

cmd/tools/fast/.gitignore

@@ -3,3 +3,4 @@ index.html
 table.html
 v.c
 v2
+fast.log

cmd/tools/fast/fast.v

@@ -1,168 +1,220 @@
-// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2023 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
 import os
 import time
+import arrays
+
+const warmup_samples = 2
+
+const max_samples = 10
+
+const discard_highest_samples = 6
 
-// TODO -usecache
 const voptions = ' -skip-unused -show-timings -stats '
 
-const exe = os.executable()
+const fast_dir = os.dir(@FILE)
 
-const fast_dir = os.dir(exe)
+const fast_log_path = os.join_path(fast_dir, 'fast.log')
 
-const vdir = @VEXEROOT
+const vdir = os.dir(os.dir(os.dir(fast_dir)))
+
+fn elog(msg string) {
+	line := '${time.now().format_ss_micro()} ${msg}\n'
+	if mut f := os.open_append(fast_log_path) {
+		f.write_string(line) or {}
+		f.close()
+	}
+	eprint(line)
+}
+
+fn lsystem(cmd string) int {
+	elog('lsystem: ${cmd}')
+	return os.system(cmd)
+}
+
+fn lexec(cmd string) string {
+	elog('  lexec: ${cmd}')
+	return os.execute_or_exit(cmd).output.trim_right('\r\n')
+}
 
 fn main() {
-	dump(fast_dir)
-	dump(vdir)
-	os.chdir(fast_dir) ?
-	if !os.exists('$vdir/v') && !os.is_dir('$vdir/vlib') {
-		println('fast.html generator needs to be located in `v/cmd/tools/fast`')
+	total_sw := time.new_stopwatch()
+	elog('fast.html generator start')
+	defer {
+		elog('fast.html generator end, total: ${total_sw.elapsed().milliseconds():6} ms')
 	}
-	println('fast.html generator\n')
-	if !os.args.contains('-noupdate') {
-		println('Fetching updates...')
-		ret := os.system('$vdir/v up')
-		if ret != 0 {
-			println('failed to update V')
-			return
-		}
-	}
-	// Fetch the last commit's hash
-	commit := exec('git rev-parse HEAD')[..8]
-	if !os.exists('table.html') {
-		os.create('table.html') ?
-	}
-	mut table := os.read_file('table.html') ?
-	if os.exists('website/index.html') {
-		uploaded_index := os.read_file('website/index.html') ?
-		if uploaded_index.contains('>$commit<') {
-			println('nothing to benchmark')
-			exit(1)
-			return
-		}
-	}
-	// for i, commit in commits {
-	message := exec('git log --pretty=format:"%s" -n1 $commit')
-	// println('\n${i + 1}/$commits.len Benchmarking commit $commit "$message"')
-	println('\nBenchmarking commit $commit "$message"')
-	// Build an optimized V
-	// println('Checking out ${commit}...')
-	// exec('git checkout $commit')
-	println('  Building vprod...')
-	os.chdir(vdir) ?
-	if os.args.contains('-noprod') {
-		exec('./v -o vprod cmd/v') // for faster debugging
-	} else {
-		exec('./v -o vprod -prod -prealloc cmd/v')
-	}
-	// cache vlib modules
-	exec('$vdir/v wipe-cache')
-	exec('$vdir/v -o v2 -prod cmd/v')
-	// measure
-	diff1 := measure('$vdir/vprod $voptions -o v.c cmd/v', 'v.c')
-	mut tcc_path := 'tcc'
-	$if freebsd {
-		tcc_path = '/usr/local/bin/tcc'
-		if vdir.contains('/tmp/cirrus-ci-build') {
-			tcc_path = 'clang'
-		}
+	//
+	mut ccompiler_path := 'tcc'
+	if vdir.contains('/tmp/cirrus-ci-build') {
+		ccompiler_path = 'clang'
 	}
 	if os.args.contains('-clang') {
-		tcc_path = 'clang'
+		ccompiler_path = 'clang'
 	}
-	diff2 := measure('$vdir/vprod $voptions -cc $tcc_path -o v2 cmd/v', 'v2')
+	elog('fast_dir: ${fast_dir} | vdir: ${vdir} | compiler: ${ccompiler_path}')
+
+	os.chdir(fast_dir)!
+	if !os.exists('${vdir}/v') && !os.is_dir('${vdir}/vlib') {
+		elog('fast.html generator needs to be located in `v/cmd/tools/fast`')
+		exit(1)
+	}
+	if !os.exists('table.html') {
+		os.create('table.html')!
+	}
+
+	if !os.args.contains('-noupdate') {
+		elog('Fetching updates...')
+		ret := lsystem('${vdir}/v up')
+		if ret != 0 {
+			elog('failed to update V, exit_code: ${ret}')
+			return
+		}
+	}
+
+	// fetch the last commit's hash
+	commit := lexec('git rev-parse HEAD')[..8]
+	if os.exists('website/index.html') {
+		uploaded_index := os.read_file('website/index.html')!
+		if uploaded_index.contains('>${commit}<') {
+			elog('NOTE: commit ${commit} had been benchmarked already.')
+			if !os.args.contains('-force') {
+				elog('nothing more to do')
+				return
+			}
+		}
+	}
+
+	os.chdir(vdir)!
+	message := lexec('git log --pretty=format:"%s" -n1 ${commit}')
+	commit_date := lexec('git log -n1 --pretty="format:%at" ${commit}')
+	date := time.unix(commit_date.i64())
+
+	elog('Benchmarking commit ${commit} , with commit message: "${message}", commit_date: ${commit_date}, date: ${date}')
+
+	// build an optimized V
+	if os.args.contains('-do-not-rebuild-vprod') {
+		if !os.exists('vprod') {
+			elog('Exiting, since if you use `-do-not-rebuild-vprod`, you should already have a `${vdir}/vprod` executable, but it is missing!')
+			return
+		}
+	} else {
+		elog('  Building vprod...')
+		if os.args.contains('-noprod') {
+			lexec('./v -o vprod cmd/v') // for faster debugging
+		} else {
+			lexec('./v -o vprod -prod -prealloc cmd/v')
+		}
+	}
+
+	if !os.args.contains('-do-not-rebuild-caches') {
+		elog('clearing caches...')
+		// cache vlib modules
+		lexec('${vdir}/v wipe-cache')
+		lexec('${vdir}/v -o vwarm_caches -cc ${ccompiler_path} cmd/v')
+	}
+
+	// measure
+	diff1 := measure('${vdir}/vprod ${voptions} -o v.c cmd/v', 'v.c')
+	diff2 := measure('${vdir}/vprod ${voptions} -cc ${ccompiler_path} -o v2 cmd/v', 'v2')
 	diff3 := 0 // measure('$vdir/vprod -native $vdir/cmd/tools/1mil.v', 'native 1mil')
-	diff4 := measure('$vdir/vprod -usecache $voptions -cc clang examples/hello_world.v',
+	diff4 := measure('${vdir}/vprod ${voptions} -cc ${ccompiler_path} examples/hello_world.v',
 		'hello.v')
 	vc_size := os.file_size('v.c') / 1000
-	// scan/parse/check/cgen
-	scan, parse, check, cgen, vlines := measure_steps(vdir)
-	// println('Building V took ${diff}ms')
-	commit_date := exec('git log -n1 --pretty="format:%at" $commit')
-	date := time.unix(commit_date.int())
-	//
-	os.chdir(fast_dir) ?
-	mut out := os.create('table.html') ?
-	// Place the new row on top
+	scan, parse, check, cgen, vlines := measure_steps_minimal(vdir)!
+
 	html_message := message.replace_each(['<', '&lt;', '>', '&gt;'])
-	table =
-		'<tr>
-		<td>$date.format()</td>
-		<td><a target=_blank href="https://github.com/vlang/v/commit/$commit">$commit</a></td>
-		<td>$html_message</td>
+
+	os.chdir(fast_dir)!
+	// place the new row on top
+	table := os.read_file('table.html')!
+	new_table :=
+		'	<tr>
+		<td>${date.format()}</td>
+		<td><a target=_blank href="https://github.com/vlang/v/commit/${commit}">${commit}</a></td>
+		<td>${html_message}</td>
 		<td>${diff1}ms</td>
 		<td>${diff2}ms</td>
 		<td>${diff3}ms</td>
 		<td>${diff4}ms</td>
-		<td>$vc_size KB</td>
+		<td>${vc_size} KB</td>
 		<td>${parse}ms</td>
 		<td>${check}ms</td>
 		<td>${cgen}ms</td>
 		<td>${scan}ms</td>
-		<td>$vlines</td>
+		<td>${vlines}</td>
 		<td>${int(f64(vlines) / f64(diff1) * 1000.0)}</td>
 	</tr>\n' +
-		table.trim_space()
-	out.writeln(table) ?
-	out.close()
-	// Regenerate index.html
-	header := os.read_file('header.html') ?
-	footer := os.read_file('footer.html') ?
-	mut res := os.create('index.html') ?
-	res.writeln(header) ?
-	res.writeln(table) ?
-	res.writeln(footer) ?
+		table.trim_space() + '\n'
+	os.write_file('table.html', new_table)!
+
+	// regenerate index.html
+	header := os.read_file('header.html')!
+	footer := os.read_file('footer.html')!
+	mut res := os.create('index.html')!
+	res.writeln(header)!
+	res.writeln(new_table)!
+	res.writeln(footer)!
 	res.close()
-	//}
-	// exec('git checkout master')
-	// os.write_file('last_commit.txt', commits[commits.len - 1]) ?
-	// Upload the result to github pages
+
+	// upload the result to github pages
 	if os.args.contains('-upload') {
-		println('uploading...')
-		os.chdir('website') ?
-		os.execute_or_exit('git checkout gh-pages')
-		os.cp('../index.html', 'index.html') ?
-		os.rm('../index.html') ?
-		os.system('git commit -am "update benchmark"')
-		os.system('git push origin gh-pages')
+		elog('uploading...')
+		os.chdir('website')!
+		lexec('git checkout gh-pages')
+		os.mv('../index.html', 'index.html')!
+		lsystem('git commit -am "update benchmark"')
+		lsystem('git push origin gh-pages')
+		elog('uploading done')
 	}
 }
 
-fn exec(s string) string {
-	e := os.execute_or_exit(s)
-	return e.output.trim_right('\r\n')
-}
-
-// returns milliseconds
+// measure returns milliseconds
 fn measure(cmd string, description string) int {
-	println('  Measuring $description')
-	println('  Warming up...')
-	println(cmd)
-	for _ in 0 .. 3 {
-		exec(cmd)
+	elog('  Measuring ${description}, warmups: ${warmup_samples}, samples: ${max_samples}, discard: ${discard_highest_samples}, with cmd: `${cmd}`')
+	for _ in 0 .. warmup_samples {
+		os.execute_or_exit(cmd)
 	}
-	println('  Building...')
 	mut runs := []int{}
-	for r in 0 .. 5 {
-		println('  Sample ${r + 1}/5')
+	for r in 0 .. max_samples {
 		sw := time.new_stopwatch()
-		exec(cmd)
-		runs << int(sw.elapsed().milliseconds())
+		os.execute_or_exit(cmd)
+		sample := int(sw.elapsed().milliseconds())
+		runs << sample
+		elog('  Sample ${r + 1:2}/${max_samples:2} ... ${sample} ms')
 	}
-	// discard lowest and highest time
 	runs.sort()
-	runs = runs[1..4]
-	mut sum := 0
-	for run in runs {
-		sum += run
+	elog('   runs before discarding: ${runs}, avg: ${f64(arrays.sum(runs) or { 0 }) / runs.len:5.2f}')
+	// Discard the highest times, since on AWS, they are caused by random load spikes,
+	// that are unpredictable, add noise and skew the statistics, without adding useful
+	// insights:
+	for _ in 0 .. discard_highest_samples {
+		runs.pop()
 	}
-	return int(sum / 3)
+	elog('   runs  after discarding: ${runs}, avg: ${f64(arrays.sum(runs) or { 0 }) / runs.len:5.2f}')
+	return int(f64(arrays.sum(runs) or { 0 }) / runs.len)
 }
 
-fn measure_steps(vdir string) (int, int, int, int, int) {
-	resp := os.execute_or_exit('$vdir/vprod $voptions -o v.c cmd/v')
+fn measure_steps_minimal(vdir string) !(int, int, int, int, int) {
+	elog('measure_steps_minimal ${vdir}, samples: ${max_samples}')
+	mut scans, mut parses, mut checks, mut cgens, mut vliness := []int{}, []int{}, []int{}, []int{}, []int{}
+	for i in 0 .. max_samples {
+		scan, parse, check, cgen, vlines, cmd := measure_steps_one_sample(vdir)
+		scans << scan
+		parses << parse
+		checks << check
+		cgens << cgen
+		vliness << vlines
+		elog('    [${i:2}/${max_samples:2}] scan: ${scan} ms, min parse: ${parse} ms, min check: ${check} ms, min cgen: ${cgen} ms, min vlines: ${vlines} ms, cmd: ${cmd}')
+	}
+	scan, parse, check, cgen, vlines := arrays.min(scans)!, arrays.min(parses)!, arrays.min(checks)!, arrays.min(cgens)!, arrays.min(vliness)!
+	elog('measure_steps_minimal => min scan: ${scan} ms, min parse: ${parse} ms, min check: ${check} ms, min cgen: ${cgen} ms, min vlines: ${vlines} ms')
+	return scan, parse, check, cgen, vlines
+}
+
+fn measure_steps_one_sample(vdir string) (int, int, int, int, int, string) {
+	cmd := '${vdir}/vprod ${voptions} -o v.c cmd/v'
+	resp := os.execute_or_exit(cmd)
 
 	mut scan, mut parse, mut check, mut cgen, mut vlines := 0, 0, 0, 0, 0
 	lines := resp.output.split_into_lines()
@@ -187,7 +239,7 @@ fn measure_steps(vdir string) (int, int, int, int, int) {
 					cgen = line[0].int()
 				}
 			} else {
-				// Fetch number of V lines
+				// fetch number of V lines
 				if line[0].contains('V') && line[0].contains('source') && line[0].contains('size') {
 					start := line[0].index(':') or { 0 }
 					end := line[0].index('lines,') or { 0 }
@@ -197,5 +249,5 @@ fn measure_steps(vdir string) (int, int, int, int, int) {
 			}
 		}
 	}
-	return scan, parse, check, cgen, vlines
+	return scan, parse, check, cgen, vlines, cmd
 }

cmd/tools/fast/fast_job.v

@@ -1,37 +1,80 @@
-// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2023 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
 import os
 import time
 
+const fast_dir = os.dir(@FILE)
+
+const vdir = os.dir(os.dir(os.dir(fast_dir)))
+
+const vexe = os.join_path(vdir, 'v')
+
+const sleep_period = 120
+
+fn elog(msg string) {
+	eprintln('${time.now().format_ss_micro()} ${msg}')
+}
+
+fn delay() {
+	elog('Sleeping for ${sleep_period} seconds...')
+	time.sleep(sleep_period * time.second)
+}
+
 // A job that runs in the background, checks for repo updates,
 // runs fast.v, pushes the HTML result to the fast.vlang.io GH pages repo.
 fn main() {
-	println(time.now())
+	os.setenv('LANG', 'C', true)
+	elog('fast_job fast_dir: ${fast_dir} | vdir: ${vdir} | vexe: ${vexe}')
+
+	os.chdir(fast_dir)!
+
+	elog('fast_job start in os.getwd(): ${os.getwd()}')
+	defer {
+		elog('fast_job end')
+	}
+
 	if !os.exists('website') {
 		println('cloning the website repo...')
 		os.system('git clone git@github.com:/vlang/website.git')
 	}
-	if !os.exists('fast') {
-		println('"fast" binary (built with `v fast.v`) was not found')
-		return
-	}
 	for {
+		elog('------------------- Checking for updates ... -------------------')
 		res_pull := os.execute('git pull --rebase')
+		elog('> res_pull.output: ${res_pull.output}')
 		if res_pull.exit_code != 0 {
-			println('failed to git pull. uncommitted changes?')
-			return
+			elog('Git pull failed. You may have uncommitted changes?')
+			delay()
+			continue
 		}
-		// println('running ./fast')
-		resp := os.execute('./fast -upload')
-		if resp.exit_code < 0 {
-			println(resp.output)
-			return
+		if res_pull.output.contains('Already up to date.') {
+			if os.args.contains('-force-update') {
+				elog('The repository was already updated, but -force-update was passed too.')
+			} else {
+				delay()
+				continue
+			}
 		}
-		if resp.exit_code != 0 {
-			println('resp != 0, skipping')
-			println(resp.output)
+
+		elog('recompiling V')
+		os.system('${os.quoted_path(vexe)} self')
+		os.system('ls -la ${os.quoted_path(vexe)}')
+
+		elog('recompiling ./fast')
+		recompile_fast_v_code := os.system('${os.quoted_path(vexe)} fast.v')
+		if recompile_fast_v_code != 0 {
+			elog('WARNING: could not recompile fast.v')
+			delay()
+			continue
 		}
-		time.sleep(180 * time.second)
+		os.system('ls -la fast fast.v')
+
+		elog('running ./fast -upload')
+		fast_exit_code := os.system('./fast -upload')
+		if fast_exit_code != 0 {
+			println('fast_exit_code = ${fast_exit_code}, != 0')
+		}
+
+		delay()
 	}
 }

cmd/tools/fast/header.html

@@ -8,23 +8,34 @@
 *, body {
 	font-family: Menlo, Monospace, 'Courier New';
 }
-table {
-	width: 1800px;
-}
-table, td {
+table, td, th {
 	border-collapse: collapse;
 	border: 1px solid #dfdfdf;
 }
+th {
+	background-color: lightgray;
+	color: black;
+	padding: 5px;
+}
 td {
 	padding: 5px;
 	position: relative;
 }
+table td:nth-child(3) {
+	width: 650px!important;
+	overflow: hidden;
+	display: block;
+	border: 0px;
+	border-bottom: 1px solid lightgray;
+}
 .diff {
 	border-radius: 2.5px;
 	color: #ffffff;
 	padding: 0 5px 0 5px;
 	position: absolute;
-	right: 5px;
+	font-size: 14px;
+	bottom: 0px;
+	right: 0px;
 }
 .minus {
 	background-color: rgb(195, 74, 104);
@@ -38,28 +49,27 @@ td {
 </style>
 </head>
 <body>
-<h2>Is V still fast?</h2>
+<h2><a href='/'>Is V still fast?</a></h2>
 
 Monitoring compilation speed for each commit. <br><br>
 Running on a free tier AWS t2.micro instance (1 vCPU). Typical desktop hardware is 2-3 times faster. <br><br>
 Source code: <a target=blank href='https://github.com/vlang/v/blob/master/cmd/tools/fast/fast.v'>fast.v</a> <br><br>
-
-
-
+Older stats: <a href="2023.html">2023</a>, <a href="2022.html">2022</a>, <a href="2021.html">2021</a>, <a href="2020.html">2020</a><br><br>
 <table>
 	<tr>
-		<td style='width:180px'>timestamp</td>
-		<td style='width:85px'>commit</td>
-		<td>commit message</td>
-		<td style='width:120px'>v -o v.c</td>
-		<td style='width:120px'>v -o v</td>
-		<td style='width:130px'>v -native 1mil.v</td>
-		<td style='width:120px'>v hello.v</td>
-		<td style='width:85px'>v.c size</td>
-		<td style='width:55px'>parse</td>
-		<td style='width:55px'>check</td>
-		<td style='width:55px'>cgen</td>
-		<td style='width:55px'>scan</td>
-		<td style='width:80px'>V lines</td>
-		<td style='width:95px'>V lines/s</td>
+		<th style='width:180px'>&nbsp;&nbsp;&nbsp;&nbsp;Timestamp&nbsp;&nbsp;&nbsp;&nbsp;</th>
+		<th style='width:85px'>Commit</th>
+		<th class='cmessage'>Commit Message</td>
+		<th style='width:120px;white-space: nowrap'>v -o v.c</th>
+		<th style='width:120px;white-space: nowrap'>v -o v</th>
+		<th style='width:130px'>v -native 1mil.v</th>
+		<th style='width:120px;white-space: nowrap'>v hello.v</th>
+		<th style='width:85px;white-space: nowrap'>v.c size</th>
+		<th style='width:55px;white-space: nowrap'>parse</th>
+		<th style='width:55px'>check</th>
+		<th style='width:55px'>cgen</th>
+		<th style='width:55px'>scan</th>
+		<th style='width:80px;white-space: nowrap'>V lines</th>
+		<th style='width:95px;white-space: nowrap'>V lines/s</th>
 	</tr>
+

cmd/tools/fuzz/map_fuzz.v

@@ -10,9 +10,9 @@ fn generate_strings(str_len int, arr_len int) []string {
 }
 
 fn fuzz1() {
-	amount := 200000 - rand.intn(100000)
-	amount2 := 200000 - rand.intn(100000)
-	len := 25 - rand.intn(10)
+	amount := 200000 - rand.intn(100000) or { 0 }
+	amount2 := 200000 - rand.intn(100000) or { 0 }
+	len := 25 - rand.intn(10) or { 0 }
 	arr := generate_strings(len, amount)
 	arr2 := generate_strings(len, amount2)
 	mut m := map[string]int{}
@@ -34,8 +34,8 @@ fn fuzz1() {
 
 fn fuzz2() {
 	mut m := map[string]int{}
-	amount := rand.intn(500000) + 1
-	len := 25 - rand.intn(10)
+	amount := rand.intn(500000) or { 0 } + 1
+	len := 25 - rand.intn(10) or { 0 }
 	arr := generate_strings(len, amount)
 	for i, x in arr {
 		m[x] = i
@@ -54,8 +54,8 @@ fn fuzz2() {
 
 fn fuzz3() {
 	mut m := map[string]int{}
-	amount := rand.intn(500000) + 1
-	len := 25 - rand.intn(10)
+	amount := rand.intn(500000) or { 0 } + 1
+	len := 25 - rand.intn(10) or { 0 }
 	arr := generate_strings(len, amount)
 	for i, x in arr {
 		if (i % 10000) == 0 {
@@ -74,8 +74,8 @@ fn fuzz3() {
 }
 
 fn fuzz4() {
-	amount := rand.intn(500000)
-	len := 25 - rand.intn(10)
+	amount := rand.intn(500000) or { 0 }
+	len := 25 - rand.intn(10) or { 0 }
 	arr := generate_strings(len, amount)
 	mut m := map[string]int{}
 	for i in 0 .. amount {
@@ -93,7 +93,7 @@ fn fuzz4() {
 }
 
 fn fuzz5() {
-	amount := rand.intn(500000) + 1
+	amount := rand.intn(500000) or { 0 } + 1
 	arr := generate_strings(20, amount)
 	mut m := map[string]int{}
 	for i in 0 .. amount {
@@ -114,8 +114,8 @@ fn fuzz5() {
 
 fn fuzz6() {
 	mut m := map[string]int{}
-	amount := rand.intn(500000) + 1
-	len := 25 - rand.intn(10)
+	amount := rand.intn(500000) or { 0 } + 1
+	len := 25 - rand.intn(10) or { 0 }
 	arr := generate_strings(len, amount)
 	for i, x in arr {
 		m[x]++
@@ -133,7 +133,7 @@ fn fuzz6() {
 
 fn main() {
 	seed := u32(time.ticks())
-	println('seed: $seed.hex()')
+	println('seed: ${seed.hex()}')
 	rand.seed([seed, seed])
 	fuzz1()
 	fuzz2()

cmd/tools/gen1m.v

@@ -2,7 +2,7 @@ fn main() {
 	for i in 0 .. 100000 {
 		println('
 fn foo${i}() {
-	x := $i
+	x := ${i}
 	mut a := 1 + x
 	a += 2
 	print(a)

cmd/tools/gen_vc.v

@@ -64,7 +64,7 @@ const (
 	// server port
 	server_port = 7171
 	// log file
-	log_file    = '$work_dir/log.txt'
+	log_file    = '${work_dir}/log.txt'
 	// log_to is either 'file' or 'terminal'
 	log_to      = 'terminal'
 )
@@ -82,7 +82,7 @@ struct GenVC {
 	// flag options
 	options FlagOptions
 mut:
-	logger &log.Log
+	logger &log.Log = unsafe { nil }
 	// true if error was experienced running generate
 	gen_error bool
 }
@@ -91,7 +91,7 @@ mut:
 struct WebhookServer {
 	vweb.Context
 mut:
-	gen_vc &GenVC = 0 // initialized in init_server
+	gen_vc &GenVC = unsafe { nil } // initialized in init_server
 }
 
 // storage for flag options
@@ -125,7 +125,7 @@ fn main() {
 	}
 	// webhook server mode
 	if flag_options.serve {
-		vweb.run<WebhookServer>(&WebhookServer{}, flag_options.port)
+		vweb.run[WebhookServer](&WebhookServer{}, flag_options.port)
 	} else {
 		// cmd mode
 		mut gen_vc := new_gen_vc(flag_options)
@@ -209,7 +209,7 @@ fn (mut gen_vc GenVC) generate() {
 		os.mkdir(gen_vc.options.work_dir) or { panic(err) }
 		// still dosen't exist... we have a problem
 		if !os.is_dir(gen_vc.options.work_dir) {
-			gen_vc.logger.error('error creating directory: $gen_vc.options.work_dir')
+			gen_vc.logger.error('error creating directory: ${gen_vc.options.work_dir}')
 			gen_vc.gen_error = true
 			return
 		}
@@ -221,10 +221,10 @@ fn (mut gen_vc GenVC) generate() {
 	// first check to see if the local v repo is behind master
 	// if it isn't behind theres no point continuing further
 	if !gen_vc.options.serve && os.is_dir(git_repo_dir_v) {
-		gen_vc.cmd_exec('git -C $git_repo_dir_v checkout master')
+		gen_vc.cmd_exec('git -C ${git_repo_dir_v} checkout master')
 		// fetch the remote repo just in case there are newer commits there
-		gen_vc.cmd_exec('git -C $git_repo_dir_v fetch')
-		git_status := gen_vc.cmd_exec('git -C $git_repo_dir_v status')
+		gen_vc.cmd_exec('git -C ${git_repo_dir_v} fetch')
+		git_status := gen_vc.cmd_exec('git -C ${git_repo_dir_v} status')
 		if !git_status.contains('behind') && !gen_vc.options.force {
 			gen_vc.logger.warn('v repository is already up to date.')
 			return
@@ -233,11 +233,11 @@ fn (mut gen_vc GenVC) generate() {
 	// delete repos
 	gen_vc.purge_repos()
 	// clone repos
-	gen_vc.cmd_exec('git clone --depth 1 https://$git_repo_v $git_repo_dir_v')
-	gen_vc.cmd_exec('git clone --depth 1 https://$git_repo_vc $git_repo_dir_vc')
+	gen_vc.cmd_exec('git clone --depth 1 https://${git_repo_v} ${git_repo_dir_v}')
+	gen_vc.cmd_exec('git clone --depth 1 https://${git_repo_vc} ${git_repo_dir_vc}')
 	// get output of git log -1 (last commit)
-	git_log_v := gen_vc.cmd_exec('git -C $git_repo_dir_v log -1 --format="commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
-	git_log_vc := gen_vc.cmd_exec('git -C $git_repo_dir_vc log -1 --format="Commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
+	git_log_v := gen_vc.cmd_exec('git -C ${git_repo_dir_v} log -1 --format="commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
+	git_log_vc := gen_vc.cmd_exec('git -C ${git_repo_dir_vc} log -1 --format="Commit %H%nDate: %ci%nDate Unix: %ct%nSubject: %s"')
 	// date of last commit in each repo
 	ts_v := git_log_v.find_between('Date:', '\n').trim_space()
 	ts_vc := git_log_vc.find_between('Date:', '\n').trim_space()
@@ -255,45 +255,45 @@ fn (mut gen_vc GenVC) generate() {
 	last_commit_subject := git_log_v.find_between('Subject:', '\n').trim_space().replace("'",
 		'"')
 	// log some info
-	gen_vc.logger.debug('last commit time ($git_repo_v): ' + last_commit_time_v.format_ss())
-	gen_vc.logger.debug('last commit time ($git_repo_vc): ' + last_commit_time_vc.format_ss())
-	gen_vc.logger.debug('last commit hash ($git_repo_v): $last_commit_hash_v')
-	gen_vc.logger.debug('last commit subject ($git_repo_v): $last_commit_subject')
+	gen_vc.logger.debug('last commit time (${git_repo_v}): ' + last_commit_time_v.format_ss())
+	gen_vc.logger.debug('last commit time (${git_repo_vc}): ' + last_commit_time_vc.format_ss())
+	gen_vc.logger.debug('last commit hash (${git_repo_v}): ${last_commit_hash_v}')
+	gen_vc.logger.debug('last commit subject (${git_repo_v}): ${last_commit_subject}')
 	// if vc repo already has a newer commit than the v repo, assume it's up to date
 	if t_unix_vc >= t_unix_v && !gen_vc.options.force {
 		gen_vc.logger.warn('vc repository is already up to date.')
 		return
 	}
 	// try build v for current os (linux in this case)
-	gen_vc.cmd_exec('make -C $git_repo_dir_v')
-	v_exec := '$git_repo_dir_v/v'
+	gen_vc.cmd_exec('make -C ${git_repo_dir_v}')
+	v_exec := '${git_repo_dir_v}/v'
 	// check if make was successful
 	gen_vc.assert_file_exists_and_is_not_too_short(v_exec, err_msg_make)
 	// build v.c for each os
 	for os_name in vc_build_oses {
 		c_file := if os_name == 'nix' { 'v.c' } else { 'v_win.c' }
-		v_flags := if os_name == 'nix' { '-os cross' } else { '-os $os_name' }
+		v_flags := if os_name == 'nix' { '-os cross' } else { '-os ${os_name}' }
 		// try generate .c file
-		gen_vc.cmd_exec('$v_exec $v_flags -o $c_file $git_repo_dir_v/cmd/v')
+		gen_vc.cmd_exec('${v_exec} ${v_flags} -o ${c_file} ${git_repo_dir_v}/cmd/v')
 		// check if the c file seems ok
 		gen_vc.assert_file_exists_and_is_not_too_short(c_file, err_msg_gen_c)
 		// embed the latest v commit hash into the c file
-		gen_vc.cmd_exec('sed -i \'1s/^/#define V_COMMIT_HASH "$last_commit_hash_v_short"\\n/\' $c_file')
+		gen_vc.cmd_exec('sed -i \'1s/^/#define V_COMMIT_HASH "${last_commit_hash_v_short}"\\n/\' ${c_file}')
 		// move to vc repo
-		gen_vc.cmd_exec('mv $c_file $git_repo_dir_vc/$c_file')
+		gen_vc.cmd_exec('mv ${c_file} ${git_repo_dir_vc}/${c_file}')
 		// add new .c file to local vc repo
-		gen_vc.cmd_exec('git -C $git_repo_dir_vc add $c_file')
+		gen_vc.cmd_exec('git -C ${git_repo_dir_vc} add ${c_file}')
 	}
 	// check if the vc repo actually changed
-	git_status := gen_vc.cmd_exec('git -C $git_repo_dir_vc status')
+	git_status := gen_vc.cmd_exec('git -C ${git_repo_dir_vc} status')
 	if git_status.contains('nothing to commit') {
 		gen_vc.logger.error('no changes to vc repo: something went wrong.')
 		gen_vc.gen_error = true
 	}
 	// commit changes to local vc repo
-	gen_vc.cmd_exec_safe("git -C $git_repo_dir_vc commit -m '[v:master] $last_commit_hash_v_short - $last_commit_subject'")
+	gen_vc.cmd_exec_safe("git -C ${git_repo_dir_vc} commit -m '[v:master] ${last_commit_hash_v_short} - ${last_commit_subject}'")
 	// push changes to remote vc repo
-	gen_vc.cmd_exec_safe('git -C $git_repo_dir_vc push https://${urllib.query_escape(git_username)}:${urllib.query_escape(git_password)}@$git_repo_vc master')
+	gen_vc.cmd_exec_safe('git -C ${git_repo_dir_vc} push https://${urllib.query_escape(git_username)}:${urllib.query_escape(git_password)}@${git_repo_vc} master')
 }
 
 // only execute when dry_run option is false, otherwise just log
@@ -312,10 +312,10 @@ fn (mut gen_vc GenVC) command_execute(cmd string, dry bool) string {
 	if dry {
 		return gen_vc.command_execute_dry(cmd)
 	}
-	gen_vc.logger.info('cmd: $cmd')
+	gen_vc.logger.info('cmd: ${cmd}')
 	r := os.execute(cmd)
 	if r.exit_code < 0 {
-		gen_vc.logger.error('$err_msg_cmd_x: "$cmd" could not start.')
+		gen_vc.logger.error('${err_msg_cmd_x}: "${cmd}" could not start.')
 		gen_vc.logger.error(r.output)
 		// something went wrong, better start fresh next time
 		gen_vc.purge_repos()
@@ -323,7 +323,7 @@ fn (mut gen_vc GenVC) command_execute(cmd string, dry bool) string {
 		return ''
 	}
 	if r.exit_code != 0 {
-		gen_vc.logger.error('$err_msg_cmd_x: "$cmd" failed.')
+		gen_vc.logger.error('${err_msg_cmd_x}: "${cmd}" failed.')
 		gen_vc.logger.error(r.output)
 		// something went wrong, better start fresh next time
 		gen_vc.purge_repos()
@@ -335,35 +335,35 @@ fn (mut gen_vc GenVC) command_execute(cmd string, dry bool) string {
 
 // just log cmd, dont execute
 fn (mut gen_vc GenVC) command_execute_dry(cmd string) string {
-	gen_vc.logger.info('cmd (dry): "$cmd"')
+	gen_vc.logger.info('cmd (dry): "${cmd}"')
 	return ''
 }
 
 // delete repo directories
 fn (mut gen_vc GenVC) purge_repos() {
 	// delete old repos (better to be fully explicit here, since these are destructive operations)
-	mut repo_dir := '$gen_vc.options.work_dir/$git_repo_dir_v'
+	mut repo_dir := '${gen_vc.options.work_dir}/${git_repo_dir_v}'
 	if os.is_dir(repo_dir) {
-		gen_vc.logger.info('purging local repo: "$repo_dir"')
-		gen_vc.cmd_exec('rm -rf $repo_dir')
+		gen_vc.logger.info('purging local repo: "${repo_dir}"')
+		gen_vc.cmd_exec('rm -rf ${repo_dir}')
 	}
-	repo_dir = '$gen_vc.options.work_dir/$git_repo_dir_vc'
+	repo_dir = '${gen_vc.options.work_dir}/${git_repo_dir_vc}'
 	if os.is_dir(repo_dir) {
-		gen_vc.logger.info('purging local repo: "$repo_dir"')
-		gen_vc.cmd_exec('rm -rf $repo_dir')
+		gen_vc.logger.info('purging local repo: "${repo_dir}"')
+		gen_vc.cmd_exec('rm -rf ${repo_dir}')
 	}
 }
 
 // check if file size is too short
 fn (mut gen_vc GenVC) assert_file_exists_and_is_not_too_short(f string, emsg string) {
 	if !os.exists(f) {
-		gen_vc.logger.error('$err_msg_build: $emsg .')
+		gen_vc.logger.error('${err_msg_build}: ${emsg} .')
 		gen_vc.gen_error = true
 		return
 	}
 	fsize := os.file_size(f)
 	if fsize < too_short_file_limit {
-		gen_vc.logger.error('$err_msg_build: $f exists, but is too short: only $fsize bytes.')
+		gen_vc.logger.error('${err_msg_build}: ${f} exists, but is too short: only ${fsize} bytes.')
 		gen_vc.gen_error = true
 		return
 	}

cmd/tools/git_pre_commit_hook.vsh

@@ -0,0 +1,52 @@
+#!/usr/bin/env -S v -raw-vsh-tmp-prefix tmp
+
+import os
+import term
+
+// This script can be used to ensure that all commited V files are vfmt-ed automatically.
+// By default, once setup, it will run `v fmt -w` on them, before commiting them.
+
+// To use the script in your V project, you need to be in the main folder
+// of your project, then do the equivalent of:
+// ```sh
+// cp /PATH/TO_YOUR/V/cmd/tools/git_pre_commit_hook.vsh .git/hooks/pre-commit
+// chmod 755 .git/hooks/pre-commit
+// ```
+//
+// Note: you can use this command:
+// `git config --bool --add hooks.stopCommitOfNonVfmtedVFiles true`
+// ... to make it just *prevent* the commiting of unformatted .v files,
+// i.e. stop the commiting, if they are not, but *without modifying them*
+// automatically (you will then need to run `v fmt -w` on them manually).
+//
+// Note 2: Git supports skipping the hooks, by passing the `--no-verify` option.
+// That can be used to commit some .v files that are not formatted, without removing
+// the hook.
+
+fn main() {
+	// This hook cares only about the changed V files, that will be commited, as reported by git itself:
+	changed := os.execute('git diff --cached --name-only --diff-filter=ACMR -- "*.v" "*.vsh" "*.vv"')
+	if changed.output == '' {
+		eprintln('>>> 0 changed V files found.')
+		exit(0)
+	}
+	vfiles := changed.output.trim_space().split('\n')
+	configured_stop_commiting := os.execute('git config --bool hooks.stopCommitOfNonVfmtedVFiles')
+	if configured_stop_commiting.output.trim_space().bool() {
+		verify_result := os.execute('v fmt -verify ${vfiles.join(' ')}')
+		if verify_result.exit_code != 0 {
+			eprintln(verify_result.output)
+		}
+		exit(verify_result.exit_code)
+	} else {
+		eprintln('The V pre commit hook will format ${vfiles.len} V file(s):')
+		// vfmt off
+		for vfile in vfiles {
+			eprintln('    ${term.bold('$vfile')}')
+		}
+		// vfmt on
+		all_vfiles_on_a_line := vfiles.map(os.quoted_path(it)).join(' ')
+		os.system('v fmt -w ${all_vfiles_on_a_line}')
+		os.system('git add ${all_vfiles_on_a_line}')
+	}
+}

cmd/tools/install_binaryen.vsh

@@ -0,0 +1,74 @@
+#!/usr/bin/env -S v -raw-vsh-tmp-prefix tmp
+
+import os
+import net.http
+
+const github_job = os.getenv('GITHUB_JOB')
+
+struct JQ {
+	tag_name string
+}
+
+fn main() {
+	root := os.real_path(os.dir(os.getenv_opt('VEXE') or { @VEXE }))
+	os.chdir(root)! // make sure that the workfolder is stable
+
+	tloc := os.join_path(root, 'thirdparty')
+	loc := os.join_path(tloc, 'binaryen')
+
+	if os.exists(loc) {
+		eprintln('thirdparty/binaryen exists, will not overwrite')
+		eprintln('delete the folder, and execute again')
+		exit(1)
+	}
+
+	/*
+	// TODO: add retries here, github requests can fail
+	jq := http.get_text('https://api.github.com/repos/WebAssembly/binaryen/releases/latest')
+	tag := json.decode(JQ, jq)!.tag_name
+        if github_job != '' {
+                dump(jq)
+                dump(tag)
+        }
+	*/
+	tag := 'version_112'
+
+	name := $if windows {
+		'x86_64-windows'
+	} $else $if macos {
+		$if arm64 {
+			'arm64-macos'
+		} $else {
+			'x86_64-macos'
+		}
+	} $else $if linux {
+		'x86_64-linux'
+	} $else {
+		eprintln('A premade binary library is not available for your system.')
+		eprintln('Build it from source, following the documentation here: https://github.com/WebAssembly/binaryen/#building')
+		exit(1)
+	}
+
+	fname := 'binaryen-${tag}'
+	url := 'https://github.com/WebAssembly/binaryen/releases/download/${tag}/${fname}-${name}.tar.gz'
+
+	saveloc := os.join_path(tloc, '${fname}.tar.gz')
+	if !os.exists(saveloc) {
+		println('Downloading archive: ${saveloc}, from url: ${url} ...')
+		http.download_file(url, saveloc)!
+		// defer { os.rm(saveloc) or {}! }
+	}
+
+	println('Extracting `${tloc}/${fname}` to `${tloc}/binaryen` ...')
+	cmd := 'tar -xvf ${saveloc} --directory ${tloc}'
+	if os.system(cmd) != 0 {
+		eprintln('`${cmd}` exited with a non zero exit code')
+		exit(1)
+	}
+
+	println(cmd)
+	println('Moving `${tloc}/${fname}` to `${tloc}/binaryen` ...')
+
+	os.rename_dir('${tloc}/${fname}', loc)!
+	println('Done. You can now use `v -b wasm file.v` .')
+}

cmd/tools/install_wabt.vsh

@@ -0,0 +1,52 @@
+#!/usr/bin/env -S v -raw-vsh-tmp-prefix tmp
+
+import os
+import net.http
+
+const root = @VROOT
+
+fn main() {
+	os.chdir(root)! // make sure that the workfolder is stable
+
+	tloc := os.join_path(root, 'thirdparty')
+	loc := os.join_path(tloc, 'wabt')
+
+	if os.exists(loc) {
+		eprintln('thirdparty/wabt exists, will not overwrite')
+		eprintln('delete the folder, and execute again')
+		exit(1)
+	}
+	tag := '1.0.32'
+	fname := 'wabt-${tag}'
+	platform := $if windows {
+		'windows'
+	} $else $if macos {
+		'macos-12'
+	} $else $if linux {
+		'ubuntu'
+	} $else {
+		eprintln('A premade binary library is not available for your system.')
+		eprintln('Build it from source, following the documentation here: https://github.com/WebAssembly/wabt/')
+		exit(1)
+	}
+	url := 'https://github.com/WebAssembly/wabt/releases/download/${tag}/${fname}-${platform}.tar.gz'
+	saveloc := os.join_path(tloc, '${fname}.tar.gz')
+	if !os.exists(saveloc) {
+		println('Downloading archive: ${saveloc}, from url: ${url} ...')
+		http.download_file(url, saveloc)!
+		// defer { os.rm(saveloc) or {}! }
+	}
+
+	println('Extracting `${tloc}/${fname}` to `${tloc}/wabt` ...')
+	cmd := 'tar -xvf ${saveloc} --directory ${tloc}'
+	if os.system(cmd) != 0 {
+		eprintln('`${cmd}` exited with a non zero exit code')
+		exit(1)
+	}
+
+	println(cmd)
+	println('Moving `${tloc}/${fname}` to `${tloc}/wabt` ...')
+
+	os.rename_dir('${tloc}/${fname}', loc)!
+	println('Done. You can now use `v test vlib/wasm` .')
+}

cmd/tools/measure/parser_speed.v

@@ -0,0 +1,67 @@
+import os
+import time
+import v.ast
+import v.pref
+import v.parser
+import v.errors
+import v.scanner
+
+fn main() {
+	files := os.args#[1..]
+	if files.len > 0 && files[0].starts_with('@') {
+		lst_path := files[0].all_after('@')
+		listed_files := os.read_file(lst_path)!.split('\n')
+		process_files(listed_files)!
+		return
+	}
+	process_files(files)!
+}
+
+fn process_files(files []string) ! {
+	mut table := ast.new_table()
+	mut pref_ := pref.new_preferences()
+	pref_.is_fmt = true
+	pref_.skip_warnings = true
+	pref_.output_mode = .silent
+	mut sw := time.new_stopwatch()
+	mut total_us := i64(0)
+	mut total_bytes := i64(0)
+	mut total_tokens := i64(0)
+	for f in files {
+		if f == '' {
+			continue
+		}
+		if f.ends_with('_test.v') {
+			continue
+		}
+		// do not measure the scanning, but only the parsing:
+		mut p := new_parser(f, .skip_comments, table, pref_)
+		///
+		sw.restart()
+		_ := p.parse()
+		f_us := sw.elapsed().microseconds()
+		///
+		total_us += f_us
+		total_bytes += p.scanner.text.len
+		total_tokens += p.scanner.all_tokens.len
+		println('${f_us:10}us ${p.scanner.all_tokens.len:10} ${p.scanner.text.len:10} ${(f64(p.scanner.text.len) / p.scanner.all_tokens.len):7.3} ${p.errors.len:4} ${f}')
+	}
+	println('${total_us:10}us ${total_tokens:10} ${total_bytes:10} ${(f64(total_tokens) / total_bytes):7.3} | speed: ${(f64(total_bytes) / total_us):2.5f} MB/s')
+}
+
+fn new_parser(path string, comments_mode scanner.CommentsMode, table &ast.Table, pref_ &pref.Preferences) &parser.Parser {
+	mut p := &parser.Parser{
+		scanner: scanner.new_scanner_file(path, comments_mode, pref_) or { panic(err) }
+		comments_mode: comments_mode
+		table: table
+		pref: pref_
+		scope: &ast.Scope{
+			start_pos: 0
+			parent: table.global_scope
+		}
+		errors: []errors.Error{}
+		warnings: []errors.Warning{}
+	}
+	p.set_path(path)
+	return p
+}

cmd/tools/measure/scanner_speed.v

@@ -0,0 +1,42 @@
+import os
+import time
+import v.scanner
+import v.pref
+
+fn main() {
+	files := os.args#[1..]
+	if files.len > 0 && files[0].starts_with('@') {
+		lst_path := files[0].all_after('@')
+		listed_files := os.read_file(lst_path)!.split('\n')
+		process_files(listed_files)!
+		return
+	}
+	process_files(files)!
+}
+
+fn process_files(files []string) ! {
+	mut pref_ := pref.new_preferences()
+	pref_.is_fmt = true
+	pref_.skip_warnings = true
+	pref_.output_mode = .silent
+	mut sw := time.new_stopwatch()
+	mut total_us := i64(0)
+	mut total_bytes := i64(0)
+	mut total_tokens := i64(0)
+	for f in files {
+		if f == '' {
+			continue
+		}
+		if f.ends_with('_test.v') {
+			continue
+		}
+		sw.restart()
+		s := scanner.new_scanner_file(f, .skip_comments, pref_)!
+		f_us := sw.elapsed().microseconds()
+		total_us += f_us
+		total_bytes += s.text.len
+		total_tokens += s.all_tokens.len
+		println('${f_us:10}us ${s.all_tokens.len:10} ${s.text.len:10} ${(f64(s.text.len) / s.all_tokens.len):7.3f} ${f}')
+	}
+	println('${total_us:10}us ${total_tokens:10} ${total_bytes:10} ${(f64(total_tokens) / total_bytes):7.3f} | speed: ${(f64(total_bytes) / total_us):2.5f} MB/s')
+}

cmd/tools/missdoc.v

@@ -1,141 +0,0 @@
-// Copyright (c) 2020 Lars Pontoppidan. All rights reserved.
-// Use of this source code is governed by an MIT license
-// that can be found in the LICENSE file.
-import os
-import flag
-
-const (
-	tool_name        = os.file_name(os.executable())
-	tool_version     = '0.0.2'
-	tool_description = 'Prints all V functions in .v files under PATH/, that do not yet have documentation comments.'
-)
-
-struct UndocumentedFN {
-	line      int
-	signature string
-	tags      []string
-}
-
-struct Options {
-	show_help    bool
-	collect_tags bool
-	deprecated   bool
-}
-
-fn collect(path string, mut l []string, f fn (string, mut []string)) {
-	if !os.is_dir(path) {
-		return
-	}
-	mut files := os.ls(path) or { return }
-	for file in files {
-		p := path + os.path_separator + file
-		if os.is_dir(p) && !os.is_link(p) {
-			collect(p, mut l, f)
-		} else if os.exists(p) {
-			f(p, mut l)
-		}
-	}
-	return
-}
-
-fn report_undocumented_functions_in_path(opt Options, path string) {
-	mut files := []string{}
-	collect_fn := fn (path string, mut l []string) {
-		if os.file_ext(path) == '.v' {
-			l << os.real_path(path)
-		}
-	}
-	collect(path, mut files, collect_fn)
-	for file in files {
-		if file.ends_with('_test.v') {
-			continue
-		}
-		report_undocumented_functions_in_file(opt, file)
-	}
-}
-
-fn report_undocumented_functions_in_file(opt Options, file string) {
-	contents := os.read_file(file) or { panic(err) }
-	lines := contents.split('\n')
-	mut info := []UndocumentedFN{}
-	for i, line in lines {
-		if line.starts_with('pub fn') || (line.starts_with('fn ') && !(line.starts_with('fn C.')
-			|| line.starts_with('fn main'))) {
-			// println('Match: $line')
-			if i > 0 && lines.len > 0 {
-				mut line_above := lines[i - 1]
-				if !line_above.starts_with('//') {
-					mut tags := []string{}
-					mut grab := true
-					for j := i - 1; j >= 0; j-- {
-						prev_line := lines[j]
-						if prev_line.contains('}') { // We've looked back to the above scope, stop here
-							break
-						} else if prev_line.starts_with('[') {
-							tags << collect_tags(prev_line)
-							continue
-						} else if prev_line.starts_with('//') { // Single-line comment
-							grab = false
-							break
-						}
-					}
-					if grab {
-						clean_line := line.all_before_last(' {')
-						info << UndocumentedFN{i + 1, clean_line, tags}
-					}
-				}
-			}
-		}
-	}
-	if info.len > 0 {
-		for undocumented_fn in info {
-			tags_str := if opt.collect_tags && undocumented_fn.tags.len > 0 {
-				'$undocumented_fn.tags'
-			} else {
-				''
-			}
-			if opt.deprecated {
-				println('$file:$undocumented_fn.line:0:$undocumented_fn.signature $tags_str')
-			} else {
-				if 'deprecated' !in undocumented_fn.tags {
-					println('$file:$undocumented_fn.line:0:$undocumented_fn.signature $tags_str')
-				}
-			}
-		}
-	}
-}
-
-fn collect_tags(line string) []string {
-	mut cleaned := line.all_before('/')
-	cleaned = cleaned.replace_each(['[', '', ']', '', ' ', ''])
-	return cleaned.split(',')
-}
-
-fn main() {
-	if os.args.len == 1 {
-		println('Usage: $tool_name PATH \n$tool_description\n$tool_name -h for more help...')
-		exit(1)
-	}
-	mut fp := flag.new_flag_parser(os.args[1..])
-	fp.application(tool_name)
-	fp.version(tool_version)
-	fp.description(tool_description)
-	fp.arguments_description('PATH [PATH]...')
-	// Collect tool options
-	opt := Options{
-		show_help: fp.bool('help', `h`, false, 'Show this help text.')
-		deprecated: fp.bool('deprecated', `d`, false, 'Include deprecated functions in output.')
-		collect_tags: fp.bool('tags', `t`, false, 'Also print function tags if any is found.')
-	}
-	if opt.show_help {
-		println(fp.usage())
-		exit(0)
-	}
-	for path in os.args[1..] {
-		if os.is_file(path) {
-			report_undocumented_functions_in_file(opt, path)
-		} else {
-			report_undocumented_functions_in_path(opt, path)
-		}
-	}
-}

cmd/tools/modules/scripting/scripting.v

@@ -24,6 +24,7 @@ pub fn cprint(omessage string) {
 		message = term.cyan(message)
 	}
 	print(message)
+	flush_stdout()
 }
 
 pub fn cprint_strong(omessage string) {
@@ -32,33 +33,36 @@ pub fn cprint_strong(omessage string) {
 		message = term.bright_green(message)
 	}
 	print(message)
+	flush_stdout()
 }
 
 pub fn cprintln(omessage string) {
 	cprint(omessage)
 	println('')
+	flush_stdout()
 }
 
 pub fn cprintln_strong(omessage string) {
 	cprint_strong(omessage)
 	println('')
+	flush_stdout()
 }
 
 pub fn verbose_trace(label string, message string) {
 	if os.getenv('VERBOSE').len > 0 {
-		slabel := '$time.now().format_ss_milli() $label'
-		cprintln('# ${slabel:-43s} : $message')
+		slabel := '${time.now().format_ss_milli()} ${label}'
+		cprintln('# ${slabel:-43s} : ${message}')
 	}
 }
 
 pub fn verbose_trace_strong(label string, omessage string) {
 	if os.getenv('VERBOSE').len > 0 {
-		slabel := '$time.now().format_ss_milli() $label'
+		slabel := '${time.now().format_ss_milli()} ${label}'
 		mut message := omessage
 		if scripting.term_colors {
 			message = term.bright_green(message)
 		}
-		cprintln('# ${slabel:-43s} : $message')
+		cprintln('# ${slabel:-43s} : ${message}')
 	}
 }
 
@@ -72,7 +76,7 @@ pub fn verbose_trace_exec_result(x os.Result) {
 			if scripting.term_colors {
 				line = term.bright_green(line)
 			}
-			cprintln('# ${lnum:3d}: $line')
+			cprintln('# ${lnum:3d}: ${line}')
 			lnum++
 		}
 		cprintln('# ----------------------------------------------------------------------')
@@ -80,27 +84,27 @@ pub fn verbose_trace_exec_result(x os.Result) {
 }
 
 fn modfn(mname string, fname string) string {
-	return '${mname}.$fname'
+	return '${mname}.${fname}'
 }
 
 pub fn chdir(path string) {
-	verbose_trace_strong(modfn(@MOD, @FN), 'cd $path')
+	verbose_trace_strong(modfn(@MOD, @FN), 'cd ${path}')
 	os.chdir(path) or {
 		verbose_trace(modfn(@MOD, @FN), '## failed.')
 		return
 	}
 }
 
-pub fn mkdir(path string) ? {
-	verbose_trace_strong(modfn(@MOD, @FN), 'mkdir $path')
+pub fn mkdir(path string) ! {
+	verbose_trace_strong(modfn(@MOD, @FN), 'mkdir ${path}')
 	os.mkdir(path) or {
 		verbose_trace(modfn(@MOD, @FN), '## failed.')
 		return err
 	}
 }
 
-pub fn mkdir_all(path string) ? {
-	verbose_trace_strong(modfn(@MOD, @FN), 'mkdir -p $path')
+pub fn mkdir_all(path string) ! {
+	verbose_trace_strong(modfn(@MOD, @FN), 'mkdir -p ${path}')
 	os.mkdir_all(path) or {
 		verbose_trace(modfn(@MOD, @FN), '## failed.')
 		return err
@@ -108,7 +112,7 @@ pub fn mkdir_all(path string) ? {
 }
 
 pub fn rmrf(path string) {
-	verbose_trace_strong(modfn(@MOD, @FN), 'rm -rf $path')
+	verbose_trace_strong(modfn(@MOD, @FN), 'rm -rf ${path}')
 	if os.exists(path) {
 		if os.is_dir(path) {
 			os.rmdir_all(path) or { panic(err) }
@@ -119,7 +123,7 @@ pub fn rmrf(path string) {
 }
 
 // execute a command, and return a result, or an error, if it failed in any way.
-pub fn exec(cmd string) ?os.Result {
+pub fn exec(cmd string) !os.Result {
 	verbose_trace_strong(modfn(@MOD, @FN), cmd)
 	x := os.execute(cmd)
 	if x.exit_code != 0 {
@@ -161,10 +165,10 @@ pub fn exit_0_status(cmd string) bool {
 
 pub fn tool_must_exist(toolcmd string) {
 	verbose_trace(modfn(@MOD, @FN), toolcmd)
-	if exit_0_status('type $toolcmd') {
+	if exit_0_status('type ${toolcmd}') {
 		return
 	}
-	eprintln('Missing tool: $toolcmd')
+	eprintln('Missing tool: ${toolcmd}')
 	eprintln('Please try again after you install it.')
 	exit(1)
 }
@@ -178,6 +182,6 @@ pub fn used_tools_must_exist(tools []string) {
 pub fn show_sizes_of_files(files []string) {
 	for f in files {
 		size := os.file_size(f)
-		println('$size $f') // println('${size:10d} $f')
+		println('${size} ${f}') // println('${size:10d} $f')
 	}
 }

cmd/tools/modules/testing/common.v

@@ -1,9 +1,11 @@
 module testing
 
 import os
+import os.cmdline
 import time
 import term
 import benchmark
+import sync
 import sync.pool
 import v.pref
 import v.util.vtest
@@ -19,13 +21,24 @@ pub const hide_oks = os.getenv('VTEST_HIDE_OK') == '1'
 
 pub const fail_fast = os.getenv('VTEST_FAIL_FAST') == '1'
 
+pub const fail_flaky = os.getenv('VTEST_FAIL_FLAKY') == '1'
+
 pub const test_only = os.getenv('VTEST_ONLY').split_any(',')
 
 pub const test_only_fn = os.getenv('VTEST_ONLY_FN').split_any(',')
 
 pub const is_node_present = os.execute('node --version').exit_code == 0
 
-pub const all_processes = os.execute('ps ax').output.split_any('\r\n')
+pub const all_processes = get_all_processes()
+
+fn get_all_processes() []string {
+	$if windows {
+		// TODO
+		return []
+	} $else {
+		return os.execute('ps ax').output.split_any('\r\n')
+	}
+}
 
 pub struct TestSession {
 pub mut:
@@ -35,30 +48,17 @@ pub mut:
 	vroot         string
 	vtmp_dir      string
 	vargs         string
-	failed        bool
 	fail_fast     bool
 	benchmark     benchmark.Benchmark
 	rm_binaries   bool = true
 	silent_mode   bool
+	show_stats    bool
 	progress_mode bool
 	root_relative bool // used by CI runs, so that the output is stable everywhere
 	nmessages     chan LogMessage // many publishers, single consumer/printer
-	nmessage_idx  int      // currently printed message index
-	nprint_ended  chan int // read to block till printing ends, 1:1
+	nmessage_idx  int // currently printed message index
 	failed_cmds   shared []string
-}
-
-enum MessageKind {
-	ok
-	fail
-	skip
-	info
-	sentinel
-}
-
-struct LogMessage {
-	message string
-	kind    MessageKind
+	reporter      Reporter = Reporter(NormalReporter{})
 }
 
 pub fn (mut ts TestSession) add_failed_cmd(cmd string) {
@@ -68,44 +68,84 @@ pub fn (mut ts TestSession) add_failed_cmd(cmd string) {
 }
 
 pub fn (mut ts TestSession) show_list_of_failed_tests() {
-	for i, cmd in ts.failed_cmds {
-		eprintln(term.failed('Failed command ${i + 1}:') + '    $cmd')
+	rlock ts.failed_cmds {
+		ts.reporter.list_of_failed_commands(ts.failed_cmds)
 	}
 }
 
-pub fn (mut ts TestSession) append_message(kind MessageKind, msg string) {
+struct MessageThreadContext {
+mut:
+	file    string
+	flow_id string
+}
+
+fn (mut ts TestSession) append_message(kind MessageKind, msg string, mtc MessageThreadContext) {
 	ts.nmessages <- LogMessage{
+		file: mtc.file
+		flow_id: mtc.flow_id
 		message: msg
 		kind: kind
+		when: time.now()
 	}
 }
 
+fn (mut ts TestSession) append_message_with_duration(kind MessageKind, msg string, d time.Duration, mtc MessageThreadContext) {
+	ts.nmessages <- LogMessage{
+		file: mtc.file
+		flow_id: mtc.flow_id
+		message: msg
+		kind: kind
+		when: time.now()
+		took: d
+	}
+}
+
+pub fn (mut ts TestSession) session_start(message string) {
+	ts.reporter.session_start(message, mut ts)
+}
+
+pub fn (mut ts TestSession) session_stop(message string) {
+	ts.reporter.session_stop(message, mut ts)
+}
+
 pub fn (mut ts TestSession) print_messages() {
-	empty := term.header(' ', ' ')
+	mut test_idx := 0
 	mut print_msg_time := time.new_stopwatch()
 	for {
 		// get a message from the channel of messages to be printed:
 		mut rmessage := <-ts.nmessages
+		ts.nmessage_idx++
+
+		// first sent *all events* to the output reporter, so it can then process them however it wants:
+		ts.reporter.report(ts.nmessage_idx, rmessage)
+
+		if rmessage.kind in [.cmd_begin, .cmd_end] {
+			// The following events, are sent before the test framework has determined,
+			// what the full completion status is. They can also be repeated multiple times,
+			// for tests that are flaky and need repeating.
+			continue
+		}
 		if rmessage.kind == .sentinel {
 			// a sentinel for stopping the printing thread
 			if !ts.silent_mode && ts.progress_mode {
-				eprintln('')
+				ts.reporter.report_stop()
 			}
-			ts.nprint_ended <- 0
 			return
 		}
 		if rmessage.kind != .info {
-			ts.nmessage_idx++
+			// info events can also be repeated, and should be ignored when determining
+			// the total order of the current test file, in the following replacements:
+			test_idx++
 		}
 		msg := rmessage.message.replace_each([
 			'TMP1',
-			'${ts.nmessage_idx:1d}',
+			'${test_idx:1d}',
 			'TMP2',
-			'${ts.nmessage_idx:2d}',
+			'${test_idx:2d}',
 			'TMP3',
-			'${ts.nmessage_idx:3d}',
+			'${test_idx:3d}',
 			'TMP4',
-			'${ts.nmessage_idx:4d}',
+			'${test_idx:4d}',
 		])
 		is_ok := rmessage.kind == .ok
 		//
@@ -114,24 +154,21 @@ pub fn (mut ts TestSession) print_messages() {
 			// Even if OK tests are suppressed,
 			// show *at least* 1 result every 10 seconds,
 			// otherwise the CI can seem stuck ...
-			eprintln(msg)
+			ts.reporter.progress(ts.nmessage_idx, msg)
 			print_msg_time.restart()
 			continue
 		}
 		if ts.progress_mode {
-			// progress mode, the last line is rewritten many times:
 			if is_ok && !ts.silent_mode {
-				print('\r$empty\r$msg')
+				ts.reporter.update_last_line(ts.nmessage_idx, msg)
 			} else {
-				// the last \n is needed, so SKIP/FAIL messages
-				// will not get overwritten by the OK ones
-				eprint('\r$empty\r$msg\n')
+				ts.reporter.update_last_line_and_move_to_next(ts.nmessage_idx, msg)
 			}
 			continue
 		}
 		if !ts.silent_mode || !is_ok {
 			// normal expanded mode, or failures in -silent mode
-			eprintln(msg)
+			ts.reporter.message(ts.nmessage_idx, msg)
 			continue
 		}
 	}
@@ -140,6 +177,14 @@ pub fn (mut ts TestSession) print_messages() {
 pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 	mut skip_files := []string{}
 	if will_compile {
+		// Skip the call_v_from_c files. They need special instructions for compilation.
+		// Check the README.md for detailed information.
+		skip_files << 'examples/call_v_from_c/v_test_print.v'
+		skip_files << 'examples/call_v_from_c/v_test_math.v'
+		// Skip the compilation of the coroutines example for now, since the Photon wrapper
+		// is only available on macos for now, and it is not yet trivial enough to
+		// build/install on the CI:
+		skip_files << 'examples/coroutines/simple_coroutines.v'
 		$if msvc {
 			skip_files << 'vlib/v/tests/const_comptime_eval_before_vinit_test.v' // _constructor used
 		}
@@ -157,13 +202,34 @@ pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 		$if windows {
 			skip_files << 'examples/database/mysql.v'
 			skip_files << 'examples/database/orm.v'
+			skip_files << 'examples/smtp/mail.v' // requires OpenSSL
 			skip_files << 'examples/websocket/ping.v' // requires OpenSSL
 			skip_files << 'examples/websocket/client-server/client.v' // requires OpenSSL
 			skip_files << 'examples/websocket/client-server/server.v' // requires OpenSSL
+			skip_files << 'vlib/v/tests/websocket_logger_interface_should_compile_test.v' // requires OpenSSL
 			$if tinyc {
 				skip_files << 'examples/database/orm.v' // try fix it
 			}
 		}
+		$if windows {
+			// TODO: remove when closures on windows are supported...
+			skip_files << 'examples/pendulum-simulation/animation.v'
+			skip_files << 'examples/pendulum-simulation/full.v'
+			skip_files << 'examples/pendulum-simulation/parallel.v'
+			skip_files << 'examples/pendulum-simulation/parallel_with_iw.v'
+			skip_files << 'examples/pendulum-simulation/sequential.v'
+		}
+		if testing.github_job == 'ubuntu-docker-musl' {
+			skip_files << 'vlib/net/openssl/openssl_compiles_test.v'
+		}
+		if testing.github_job == 'tests-sanitize-memory-clang' {
+			skip_files << 'vlib/net/openssl/openssl_compiles_test.v'
+		}
+		if testing.github_job == 'windows-tcc' {
+			// TODO: fix these by adding declarations for the missing functions in the prebuilt tcc
+			skip_files << 'vlib/net/mbedtls/mbedtls_compiles_test.v'
+			skip_files << 'vlib/net/ssl/ssl_compiles_test.v'
+		}
 		if testing.github_job != 'sokol-shaders-can-be-compiled' {
 			// These examples need .h files that are produced from the supplied .glsl files,
 			// using by the shader compiler tools in https://github.com/floooh/sokol-tools-bin/archive/pre-feb2021-api-changes.tar.gz
@@ -187,24 +253,68 @@ pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 			skip_files << 'examples/sokol/sounds/wav_player.v'
 			skip_files << 'examples/sokol/sounds/simple_sin_tones.v'
 		}
+		$if !macos {
+			skip_files << 'examples/macos_tray/tray.v'
+		}
+		// examples/wasm/mandelbrot/mandelbrot.v requires special compilation flags: `-b wasm -os browser`, skip it for now:
+		skip_files << 'examples/wasm/mandelbrot/mandelbrot.v'
+
+		// TODO: always build the wasm_builder in the future, not just when it was build manually before:
+		wasm_builder_executable := $if !windows {
+			'cmd/tools/builders/wasm_builder'
+		} $else {
+			'cmd/tools/builders/wasm_builder.exe'
+		}
+		if !os.exists(wasm_builder_executable) {
+			skip_files << os.join_path('cmd/tools/builders/wasm_builder.v')
+		}
 	}
-	vargs := _vargs.replace('-progress', '').replace('-progress', '')
+	vargs := _vargs.replace('-progress', '')
 	vexe := pref.vexe_path()
 	vroot := os.dir(vexe)
 	new_vtmp_dir := setup_new_vtmp_folder()
 	if term.can_show_color_on_stderr() {
 		os.setenv('VCOLORS', 'always', true)
 	}
-	return TestSession{
+	mut ts := TestSession{
 		vexe: vexe
 		vroot: vroot
 		skip_files: skip_files
 		fail_fast: testing.fail_fast
+		show_stats: '-stats' in vargs.split(' ')
 		vargs: vargs
 		vtmp_dir: new_vtmp_dir
 		silent_mode: _vargs.contains('-silent')
 		progress_mode: _vargs.contains('-progress')
 	}
+	ts.handle_test_runner_option()
+	return ts
+}
+
+fn (mut ts TestSession) handle_test_runner_option() {
+	test_runner := cmdline.option(os.args, '-test-runner', 'normal')
+	if test_runner !in pref.supported_test_runners {
+		eprintln('v test: `-test-runner ${test_runner}` is not using one of the supported test runners: ${pref.supported_test_runners_list()}')
+	}
+	test_runner_implementation_file := os.join_path(ts.vroot, 'cmd/tools/modules/testing/output_${test_runner}.v')
+	if !os.exists(test_runner_implementation_file) {
+		eprintln('v test: using `-test-runner ${test_runner}` needs ${test_runner_implementation_file} to exist, and contain a valid testing.Reporter implementation for that runner. See `cmd/tools/modules/testing/output_dump.v` for an example.')
+		exit(1)
+	}
+	match test_runner {
+		'normal' {
+			// default, nothing to do
+		}
+		'dump' {
+			ts.reporter = DumpReporter{}
+		}
+		'teamcity' {
+			ts.reporter = TeamcityReporter{}
+		}
+		else {
+			dump('just set ts.reporter to an instance of your own struct here')
+		}
+	}
 }
 
 pub fn (mut ts TestSession) init() {
@@ -254,37 +364,43 @@ pub fn (mut ts TestSession) test() {
 	}
 	ts.benchmark.njobs = njobs
 	mut pool_of_test_runners := pool.new_pool_processor(callback: worker_trunner)
-	// for handling messages across threads
+	// ensure that the nmessages queue/channel, has enough capacity for handling many messages across threads, without blocking
 	ts.nmessages = chan LogMessage{cap: 10000}
-	ts.nprint_ended = chan int{cap: 0}
 	ts.nmessage_idx = 0
-	go ts.print_messages()
+	printing_thread := spawn ts.print_messages()
 	pool_of_test_runners.set_shared_context(ts)
+	ts.reporter.worker_threads_start(remaining_files, mut ts)
+	// all the testing happens here:
 	pool_of_test_runners.work_on_pointers(unsafe { remaining_files.pointers() })
+	//
 	ts.benchmark.stop()
-	ts.append_message(.sentinel, '') // send the sentinel
-	_ := <-ts.nprint_ended // wait for the stop of the printing thread
-	eprintln(term.h_divider('-'))
+	ts.append_message(.sentinel, '', MessageThreadContext{ flow_id: '-1' }) // send the sentinel
+	printing_thread.wait()
+	ts.reporter.worker_threads_finish(mut ts)
+	ts.reporter.divider()
+	ts.show_list_of_failed_tests()
 	// cleanup generated .tmp.c files after successful tests:
 	if ts.benchmark.nfail == 0 {
 		if ts.rm_binaries {
 			os.rmdir_all(ts.vtmp_dir) or {}
 		}
 	}
-	ts.show_list_of_failed_tests()
+	// remove empty session folders:
+	if os.ls(ts.vtmp_dir) or { [] }.len == 0 {
+		os.rmdir_all(ts.vtmp_dir) or {}
+	}
 }
 
 fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
-	mut ts := &TestSession(p.get_shared_context())
+	mut ts := unsafe { &TestSession(p.get_shared_context()) }
 	if ts.fail_fast {
-		if ts.failed {
+		if ts.failed_cmds.len > 0 {
 			return pool.no_result
 		}
 	}
 	tmpd := ts.vtmp_dir
-	show_stats := '-stats' in ts.vargs.split(' ')
 	// tls_bench is used to format the step messages/timings
-	mut tls_bench := &benchmark.Benchmark(p.get_thread_context(idx))
+	mut tls_bench := unsafe { &benchmark.Benchmark(p.get_thread_context(idx)) }
 	if isnil(tls_bench) {
 		tls_bench = benchmark.new_benchmark_pointer()
 		tls_bench.set_total_expected_steps(ts.benchmark.nexpected_steps)
@@ -292,17 +408,19 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 	}
 	tls_bench.no_cstep = true
 	tls_bench.njobs = ts.benchmark.njobs
-	mut relative_file := os.real_path(p.get_item<string>(idx))
+	mut relative_file := os.real_path(p.get_item[string](idx))
 	mut cmd_options := [ts.vargs]
 	mut run_js := false
 
 	is_fmt := ts.vargs.contains('fmt')
+	is_vet := ts.vargs.contains('vet')
+	produces_file_output := !(is_fmt || is_vet)
 
 	if relative_file.ends_with('js.v') {
-		if !is_fmt {
+		if produces_file_output {
 			cmd_options << ' -b js'
+			run_js = true
 		}
-		run_js = true
 	}
 
 	if relative_file.contains('global') && !is_fmt {
@@ -312,6 +430,10 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 		relative_file = relative_file.replace(ts.vroot + os.path_separator, '')
 	}
 	file := os.real_path(relative_file)
+	mtc := MessageThreadContext{
+		file: file
+		flow_id: thread_id.str()
+	}
 	normalised_relative_file := relative_file.replace('\\', '/')
 	// Ensure that the generated binaries will be stored in the temporary folder.
 	// Remove them after a test passes/fails.
@@ -324,13 +446,11 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 		fname.replace('.v', '')
 	}
 	generated_binary_fpath := os.join_path_single(tmpd, generated_binary_fname)
-	if os.exists(generated_binary_fpath) {
+	if produces_file_output {
 		if ts.rm_binaries {
 			os.rm(generated_binary_fpath) or {}
 		}
-	}
 
-	if !ts.vargs.contains('fmt') {
 		cmd_options << ' -o ${os.quoted_path(generated_binary_fpath)}'
 	}
 	cmd := '${os.quoted_path(ts.vexe)} ' + cmd_options.join(' ') + ' ${os.quoted_path(file)}'
@@ -340,20 +460,42 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 		ts.benchmark.skip()
 		tls_bench.skip()
 		if !testing.hide_skips {
-			ts.append_message(.skip, tls_bench.step_message_skip(normalised_relative_file))
+			ts.append_message(.skip, tls_bench.step_message_skip(normalised_relative_file),
+				mtc)
 		}
 		return pool.no_result
 	}
-	if show_stats {
-		ts.append_message(.ok, term.h_divider('-'))
-		mut status := os.system(cmd)
+	if ts.show_stats {
+		ts.reporter.divider()
+
+		ts.append_message(.cmd_begin, cmd, mtc)
+		d_cmd := time.new_stopwatch()
+
+		mut res := os.execute(cmd)
+		if res.exit_code != 0 {
+			eprintln(res.output)
+		} else {
+			println(res.output)
+		}
+		mut status := res.exit_code
+
+		mut cmd_duration := d_cmd.elapsed()
+		ts.append_message_with_duration(.cmd_end, '', cmd_duration, mtc)
+
 		if status != 0 {
 			details := get_test_details(file)
-			os.setenv('VTEST_RETRY_MAX', '$details.retry', true)
+			os.setenv('VTEST_RETRY_MAX', '${details.retry}', true)
 			for retry := 1; retry <= details.retry; retry++ {
-				ts.append_message(.info, '                 retrying $retry/$details.retry of $relative_file ...')
-				os.setenv('VTEST_RETRY', '$retry', true)
+				ts.append_message(.info, '  [stats]        retrying ${retry}/${details.retry} of ${relative_file} ; known flaky: ${details.flaky} ...',
+					mtc)
+				os.setenv('VTEST_RETRY', '${retry}', true)
+
+				ts.append_message(.cmd_begin, cmd, mtc)
+				d_cmd_2 := time.new_stopwatch()
 				status = os.system(cmd)
+				cmd_duration = d_cmd_2.elapsed()
+				ts.append_message_with_duration(.cmd_end, '', cmd_duration, mtc)
+
 				if status == 0 {
 					unsafe {
 						goto test_passed_system
@@ -361,7 +503,19 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 				}
 				time.sleep(500 * time.millisecond)
 			}
-			ts.failed = true
+			if details.flaky && !testing.fail_flaky {
+				ts.append_message(.info, '   *FAILURE* of the known flaky test file ${relative_file} is ignored, since VTEST_FAIL_FLAKY is 0 . Retry count: ${details.retry} .',
+					mtc)
+				unsafe {
+					goto test_passed_system
+				}
+			}
+
+			// most probably compiler error
+			if res.output.contains(': error: ') {
+				ts.append_message(.cannot_compile, 'Cannot compile file ${file}', mtc)
+			}
+
 			ts.benchmark.fail()
 			tls_bench.fail()
 			ts.add_failed_cmd(cmd)
@@ -373,49 +527,68 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 		}
 	} else {
 		if testing.show_start {
-			ts.append_message(.info, '                 starting $relative_file ...')
+			ts.append_message(.info, '                 starting ${relative_file} ...',
+				mtc)
 		}
+		ts.append_message(.cmd_begin, cmd, mtc)
+		d_cmd := time.new_stopwatch()
 		mut r := os.execute(cmd)
+		mut cmd_duration := d_cmd.elapsed()
+		ts.append_message_with_duration(.cmd_end, r.output, cmd_duration, mtc)
+
 		if r.exit_code < 0 {
-			ts.failed = true
 			ts.benchmark.fail()
 			tls_bench.fail()
-			ts.append_message(.fail, tls_bench.step_message_fail(normalised_relative_file))
+			ts.append_message_with_duration(.fail, tls_bench.step_message_fail(normalised_relative_file),
+				cmd_duration, mtc)
 			ts.add_failed_cmd(cmd)
 			return pool.no_result
 		}
 		if r.exit_code != 0 {
 			details := get_test_details(file)
-			os.setenv('VTEST_RETRY_MAX', '$details.retry', true)
+			os.setenv('VTEST_RETRY_MAX', '${details.retry}', true)
 			for retry := 1; retry <= details.retry; retry++ {
-				ts.append_message(.info, '                 retrying $retry/$details.retry of $relative_file ...')
-				os.setenv('VTEST_RETRY', '$retry', true)
+				ts.append_message(.info, '                 retrying ${retry}/${details.retry} of ${relative_file} ; known flaky: ${details.flaky} ...',
+					mtc)
+				os.setenv('VTEST_RETRY', '${retry}', true)
+
+				ts.append_message(.cmd_begin, cmd, mtc)
+				d_cmd_2 := time.new_stopwatch()
 				r = os.execute(cmd)
+				cmd_duration = d_cmd_2.elapsed()
+				ts.append_message_with_duration(.cmd_end, r.output, cmd_duration, mtc)
+
 				if r.exit_code == 0 {
 					unsafe {
 						goto test_passed_execute
 					}
 				}
 			}
-			ts.failed = true
+			if details.flaky && !testing.fail_flaky {
+				ts.append_message(.info, '   *FAILURE* of the known flaky test file ${relative_file} is ignored, since VTEST_FAIL_FLAKY is 0 . Retry count: ${details.retry} .',
+					mtc)
+				unsafe {
+					goto test_passed_execute
+				}
+			}
 			ts.benchmark.fail()
 			tls_bench.fail()
 			ending_newline := if r.output.ends_with('\n') { '\n' } else { '' }
-			ts.append_message(.fail, tls_bench.step_message_fail('$normalised_relative_file\n$r.output.trim_space()$ending_newline'))
+			ts.append_message_with_duration(.fail, tls_bench.step_message_fail('${normalised_relative_file}\n${r.output.trim_space()}${ending_newline}'),
+				cmd_duration, mtc)
 			ts.add_failed_cmd(cmd)
 		} else {
 			test_passed_execute:
 			ts.benchmark.ok()
 			tls_bench.ok()
 			if !testing.hide_oks {
-				ts.append_message(.ok, tls_bench.step_message_ok(normalised_relative_file))
+				ts.append_message_with_duration(.ok, tls_bench.step_message_ok(normalised_relative_file),
+					cmd_duration, mtc)
 			}
 		}
 	}
-	if os.exists(generated_binary_fpath) {
-		if ts.rm_binaries {
-			os.rm(generated_binary_fpath) or {}
-		}
+	if produces_file_output && ts.rm_binaries {
+		os.rm(generated_binary_fpath) or {}
 	}
 	return pool.no_result
 }
@@ -423,7 +596,7 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 pub fn vlib_should_be_present(parent_dir string) {
 	vlib_dir := os.join_path_single(parent_dir, 'vlib')
 	if !os.is_dir(vlib_dir) {
-		eprintln('$vlib_dir is missing, it must be next to the V executable')
+		eprintln('${vlib_dir} is missing, it must be next to the V executable')
 		exit(1)
 	}
 }
@@ -435,7 +608,7 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 	vargs := zargs.replace(vexe, '')
 	eheader(main_label)
 	if vargs.len > 0 {
-		eprintln('v compiler args: "$vargs"')
+		eprintln('v compiler args: "${vargs}"')
 	}
 	mut session := new_test_session(vargs, true)
 	files := os.walk_ext(os.join_path_single(parent_dir, folder), '.v')
@@ -443,12 +616,12 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 	mut skipped := oskipped.clone()
 	next_file: for f in files {
 		fnormalised := f.replace('\\', '/')
-		// NB: a `testdata` folder, is the preferred name of a folder, containing V code,
+		// Note: a `testdata` folder, is the preferred name of a folder, containing V code,
 		// that you *do not want* the test framework to find incidentally for various reasons,
 		// for example module import tests, or subtests, that are compiled/run by other parent tests
 		// in specific configurations, etc.
 		if fnormalised.contains('testdata/') || fnormalised.contains('modules/')
-			|| f.contains('preludes/') {
+			|| fnormalised.contains('preludes/') {
 			continue
 		}
 		$if windows {
@@ -466,7 +639,8 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 			skipped << skipped_f
 		}
 		for skip_prefix in oskipped {
-			if f.starts_with(skip_prefix) {
+			skip_folder := skip_prefix + '/'
+			if fnormalised.starts_with(skip_folder) {
 				continue next_file
 			}
 		}
@@ -480,13 +654,13 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 pub type FnTestSetupCb = fn (mut session TestSession)
 
 pub fn v_build_failing_skipped(zargs string, folder string, oskipped []string, cb FnTestSetupCb) bool {
-	main_label := 'Building $folder ...'
-	finish_label := 'building $folder'
+	main_label := 'Building ${folder} ...'
+	finish_label := 'building ${folder}'
 	mut session := prepare_test_session(zargs, folder, oskipped, main_label)
 	cb(mut session)
 	session.test()
 	eprintln(session.benchmark.total_message(finish_label))
-	return session.failed
+	return session.failed_cmds.len > 0
 }
 
 pub fn build_v_cmd_failed(cmd string) bool {
@@ -510,22 +684,22 @@ pub fn building_any_v_binaries_failed() bool {
 	vlib_should_be_present(parent_dir)
 	os.chdir(parent_dir) or { panic(err) }
 	mut failed := false
-	v_build_commands := ['$vexe -o v_g             -g  cmd/v', '$vexe -o v_prod_g  -prod -g  cmd/v',
-		'$vexe -o v_cg            -cg cmd/v', '$vexe -o v_prod_cg -prod -cg cmd/v',
-		'$vexe -o v_prod    -prod     cmd/v']
+	v_build_commands := ['${vexe} -o v_g             -g  cmd/v',
+		'${vexe} -o v_prod_g  -prod -g  cmd/v', '${vexe} -o v_cg            -cg cmd/v',
+		'${vexe} -o v_prod_cg -prod -cg cmd/v', '${vexe} -o v_prod    -prod     cmd/v']
 	mut bmark := benchmark.new_benchmark()
 	for cmd in v_build_commands {
 		bmark.step()
 		if build_v_cmd_failed(cmd) {
 			bmark.fail()
 			failed = true
-			eprintln(bmark.step_message_fail('command: $cmd . See details above ^^^^^^^'))
+			eprintln(bmark.step_message_fail('command: ${cmd} . See details above ^^^^^^^'))
 			eprintln('')
 			continue
 		}
 		bmark.ok()
 		if !testing.hide_oks {
-			eprintln(bmark.step_message_ok('command: $cmd'))
+			eprintln(bmark.step_message_ok('command: ${cmd}'))
 		}
 	}
 	bmark.stop()
@@ -534,17 +708,12 @@ pub fn building_any_v_binaries_failed() bool {
 	return failed
 }
 
-pub fn eheader(msg string) {
-	eprintln(term.header_left(msg, '-'))
-}
-
-pub fn header(msg string) {
-	println(term.header_left(msg, '-'))
-}
-
+// setup_new_vtmp_folder creates a new nested folder inside VTMP, then resets VTMP to it,
+// so that V programs/tests will write their temporary files to new location.
+// The new nested folder, and its contents, will get removed after all tests/programs succeed.
 pub fn setup_new_vtmp_folder() string {
 	now := time.sys_mono_now()
-	new_vtmp_dir := os.join_path(os.temp_dir(), 'v', 'test_session_$now')
+	new_vtmp_dir := os.join_path(os.vtmp_dir(), 'tsession_${sync.thread_id().hex()}_${now}')
 	os.mkdir_all(new_vtmp_dir) or { panic(err) }
 	os.setenv('VTMP', new_vtmp_dir, true)
 	return new_vtmp_dir
@@ -553,6 +722,7 @@ pub fn setup_new_vtmp_folder() string {
 pub struct TestDetails {
 pub mut:
 	retry int
+	flaky bool // when flaky tests fail, the whole run is still considered successfull, unless VTEST_FAIL_FLAKY is 1
 }
 
 pub fn get_test_details(file string) TestDetails {
@@ -562,15 +732,27 @@ pub fn get_test_details(file string) TestDetails {
 		if line.starts_with('// vtest retry:') {
 			res.retry = line.all_after(':').trim_space().int()
 		}
+		if line.starts_with('// vtest flaky:') {
+			res.flaky = line.all_after(':').trim_space().bool()
+		}
 	}
 	return res
 }
 
-pub fn find_started_process(pname string) ?string {
+pub fn find_started_process(pname string) !string {
 	for line in testing.all_processes {
 		if line.contains(pname) {
 			return line
 		}
 	}
-	return error('could not find process matching $pname')
+	return error('could not find process matching ${pname}')
+}
+
+pub fn eheader(msg string) {
+	eprintln(term.header_left(msg, '-'))
+}
+
+pub fn header(msg string) {
+	println(term.header_left(msg, '-'))
+	flush_stdout()
 }

cmd/tools/modules/testing/output.v

@@ -0,0 +1,46 @@
+module testing
+
+import time
+
+pub enum MessageKind {
+	cmd_begin // sent right before *each* _test.v file execution, the resulting status is not known yet, but the _test.v file itself is
+	cmd_end // sent right after *each* _test.v file execution, the message contains the output of that execution
+	//
+	ok // success of a _test.v file
+	fail // failed _test.v file, one or more assertions failed
+	skip // the _test.v file was skipped for some reason
+	info // a generic information message, detailing the actions of the `v test` program (some tests could be repeated for example, and the details are sent with an .info status)
+	//
+	cannot_compile // when the _test.v file compiled with errors
+	//
+	sentinel // send just once after all executions are done; it signals that the reporting/printing thread should stop the loop and exit
+}
+
+pub struct LogMessage {
+pub:
+	kind    MessageKind   // see the MessageKind declaration above
+	file    string        // the _test.v file that the message is about
+	when    time.Time     // when was the message sent (messages are sent by the execution threads at the *end* of each event)
+	flow_id string        // the messages of each thread, producing LogMessage, will have all the same unique flowid. Messages by other threads will have other flowid. If you use VJOBS=1 to serialise the execution, then all messages will have the same flowid.
+	took    time.Duration // the duration of the event, that this message describes
+	message string        // the actual message text; the result of the event, that the message describes; most reporters could ignore this, since it could be reconstructed by the other fields
+}
+
+pub interface Reporter {
+mut:
+	session_start(message string, mut ts TestSession) // called once per test session, in the main thread, suitable for setting up supporting infrastructure.
+	session_stop(message string, mut ts TestSession) // called once per test session, in the main thread, after everything else, suitable for summaries, creating .xml reports, uploads etc.
+	worker_threads_start(files []string, mut ts TestSession) // called once per test session, in the main thread, right before all the worker threads start
+	worker_threads_finish(mut ts TestSession) // called once per test session, in the main thread, right after all the worker threads finish
+	//
+	report(index int, log_msg LogMessage) // called once per each message, that will be shown (ok/fail/skip etc), only in the reporting thread.
+	report_stop() // called just once after all messages are processed, only in the reporting thread, but before stop_session.
+	//
+	// TODO: reconsider, whether the next methods, should be kept for all reporters, or just moved inside the normal reporter, to simplify the interface
+	progress(index int, message string)
+	update_last_line(index int, message string)
+	update_last_line_and_move_to_next(index int, message string)
+	message(index int, message string)
+	divider() // called to show a long ---------- horizontal line; can be safely ignored in most reporters; used in the main thread.
+	list_of_failed_commands(cmds []string) // called after all testing is done, to produce a small summary that only lists the failed commands, so that they can be retried manually if needed, without forcing the user to scroll and find them.
+}

cmd/tools/modules/testing/output_dump.v

@@ -0,0 +1,64 @@
+module testing
+
+// DumpReporter implements the interface testing.Reporter.
+// It is used by `v -test-runner dump test .`
+pub struct DumpReporter {
+mut:
+	files []string
+}
+
+//
+
+pub fn (mut r DumpReporter) worker_threads_start(files []string, mut ts TestSession) {
+	eprintln('> ${@METHOD} | files: ${files}')
+	r.files = files
+}
+
+pub fn (r DumpReporter) worker_threads_finish(mut ts TestSession) {
+	eprintln('> ${@METHOD}')
+}
+
+//
+
+pub fn (r DumpReporter) session_start(message string, mut ts TestSession) {
+	eprintln('> ${@METHOD} | message: ${message}')
+	// dump(ts)
+}
+
+pub fn (r DumpReporter) session_stop(message string, mut ts TestSession) {
+	eprintln('> ${@METHOD} | message: ${message}')
+}
+
+//
+
+pub fn (r DumpReporter) report(index int, message LogMessage) {
+	eprintln('> ${@METHOD} | index: ${index} | message: ${message}')
+}
+
+pub fn (r DumpReporter) report_stop() {
+	eprintln('> ${@METHOD}')
+}
+
+pub fn (r DumpReporter) progress(index int, message string) {
+	eprintln('> ${@METHOD} | index: ${index} | message: ${message}')
+}
+
+pub fn (r DumpReporter) update_last_line(index int, message string) {
+	eprintln('> ${@METHOD} | index: ${index} | message: ${message}')
+}
+
+pub fn (r DumpReporter) update_last_line_and_move_to_next(index int, message string) {
+	eprintln('> ${@METHOD} | index: ${index} | message: ${message}')
+}
+
+pub fn (r DumpReporter) message(index int, message string) {
+	eprintln('> ${@METHOD} | index: ${index} | message: ${message}')
+}
+
+pub fn (r DumpReporter) divider() {
+	eprintln('> ${@METHOD}')
+}
+
+pub fn (r DumpReporter) list_of_failed_commands(failed_cmds []string) {
+	eprintln('> ${@METHOD} | failed_cmds: ${failed_cmds}')
+}

cmd/tools/modules/testing/output_normal.v

@@ -0,0 +1,73 @@
+module testing
+
+import term
+
+pub const empty = term.header(' ', ' ')
+
+// NormalReporter implements the interface testing.Reporter.
+// It is used by default by `v test .`
+// It was extracted by the original non customiseable output implementation directly in cmd/tools/modules/testing/common.v
+pub struct NormalReporter {
+}
+
+pub fn (r NormalReporter) session_start(message string, mut ts TestSession) {
+	header(message)
+}
+
+pub fn (r NormalReporter) session_stop(message string, mut ts TestSession) {
+	println(ts.benchmark.total_message(message))
+}
+
+// the most general form; it may be useful for other reporters
+// in the normal one, it currently does nothing
+pub fn (r NormalReporter) report(index int, message LogMessage) {
+	// eprintln('> ${@METHOD} index: $index | message: $message')
+}
+
+pub fn (r NormalReporter) report_stop() {
+	// eprintln('> ${@METHOD}')
+	eprintln('')
+}
+
+//// TODO: reconsider if these should be public:
+
+pub fn (r NormalReporter) progress(index int, message string) {
+	eprintln(message)
+}
+
+// in progress mode, the last line will be rewritten many times, and does not end with \n
+// the \n will be printed just once when some progress has been made.
+pub fn (r NormalReporter) update_last_line(index int, message string) {
+	print('\r${testing.empty}\r${message}')
+	flush_stdout()
+}
+
+pub fn (r NormalReporter) update_last_line_and_move_to_next(index int, message string) {
+	// the last \n is needed, so SKIP/FAIL messages
+	// will not get overwritten by the OK ones
+	eprint('\r${testing.empty}\r${message}\n')
+}
+
+pub fn (r NormalReporter) message(index int, message string) {
+	eprintln(message)
+}
+
+pub fn (r NormalReporter) divider() {
+	eprintln(term.h_divider('-'))
+}
+
+//
+
+pub fn (r NormalReporter) worker_threads_start(files []string, mut ts TestSession) {
+	// eprintln('> ${@METHOD}')
+}
+
+pub fn (r NormalReporter) worker_threads_finish(mut ts TestSession) {
+	// eprintln('> ${@METHOD}')
+}
+
+pub fn (r NormalReporter) list_of_failed_commands(failed_cmds []string) {
+	for i, cmd in failed_cmds {
+		eprintln(term.failed('Failed command ${i + 1}:') + '    ${cmd}')
+	}
+}

cmd/tools/modules/testing/output_teamcity.v

@@ -0,0 +1,60 @@
+module testing
+
+// TeamcityReporter implements the interface `testing.Reporter`.
+// It is used by `v -test-runner teamcity test .`
+pub struct TeamcityReporter {
+}
+
+pub fn (r TeamcityReporter) session_start(message string, mut ts TestSession) {
+}
+
+pub fn (r TeamcityReporter) session_stop(message string, mut ts TestSession) {
+}
+
+pub fn (r TeamcityReporter) report(index int, message LogMessage) {
+	name := r.get_test_suite_name_by_file(message.file)
+	match message.kind {
+		.cmd_begin {
+			eprintln("##teamcity[testSuiteStarted name='${name}' flowId='${message.flow_id}']")
+		}
+		.cmd_end {
+			eprintln("##teamcity[testSuiteFinished name='${name}' flowId='${message.flow_id}' duration='${message.took}']")
+		}
+		.cannot_compile {
+			eprintln("##teamcity[testFailed name='${name}' message='${message.message}']")
+		}
+		else {}
+	}
+}
+
+pub fn (r TeamcityReporter) get_test_suite_name_by_file(path string) string {
+	file_name := path.replace('\\', '/').split('/').last()
+	return file_name.split('.').first()
+}
+
+pub fn (r TeamcityReporter) report_stop() {
+}
+
+pub fn (r TeamcityReporter) progress(index int, message string) {
+}
+
+pub fn (r TeamcityReporter) update_last_line(index int, message string) {
+}
+
+pub fn (r TeamcityReporter) update_last_line_and_move_to_next(index int, message string) {
+}
+
+pub fn (r TeamcityReporter) message(index int, message string) {
+}
+
+pub fn (r TeamcityReporter) divider() {
+}
+
+pub fn (r TeamcityReporter) worker_threads_start(files []string, mut ts TestSession) {
+}
+
+pub fn (r TeamcityReporter) worker_threads_finish(mut ts TestSession) {
+}
+
+pub fn (r TeamcityReporter) list_of_failed_commands(failed_cmds []string) {
+}

cmd/tools/modules/vgit/vgit.v

@@ -22,9 +22,9 @@ pub fn validate_commit_exists(commit string) {
 	if commit.len == 0 {
 		return
 	}
-	cmd := "git cat-file -t '$commit' "
+	cmd := "git cat-file -t '${commit}' "
 	if !scripting.exit_0_status(cmd) {
-		eprintln('Commit: "$commit" does not exist in the current repository.')
+		eprintln('Commit: "${commit}" does not exist in the current repository.')
 		exit(3)
 	}
 }
@@ -50,39 +50,39 @@ pub fn prepare_vc_source(vcdir string, cdir string, commit string) (string, stri
 	// Building a historic v with the latest vc is not always possible ...
 	// It is more likely, that the vc *at the time of the v commit*,
 	// or slightly before that time will be able to build the historic v:
-	vline := scripting.run('git rev-list -n1 --timestamp "$commit" ')
+	vline := scripting.run('git rev-list -n1 --timestamp "${commit}" ')
 	v_timestamp, v_commithash := line_to_timestamp_and_commit(vline)
-	scripting.verbose_trace(@FN, 'v_timestamp: $v_timestamp | v_commithash: $v_commithash')
+	scripting.verbose_trace(@FN, 'v_timestamp: ${v_timestamp} | v_commithash: ${v_commithash}')
 	check_v_commit_timestamp_before_self_rebuilding(v_timestamp)
 	scripting.chdir(vcdir)
 	scripting.run('git checkout --quiet master')
 	//
 	mut vccommit := ''
 	vcbefore_subject_match := scripting.run('git rev-list HEAD -n1 --timestamp --grep=${v_commithash[0..7]} ')
-	scripting.verbose_trace(@FN, 'vcbefore_subject_match: $vcbefore_subject_match')
+	scripting.verbose_trace(@FN, 'vcbefore_subject_match: ${vcbefore_subject_match}')
 	if vcbefore_subject_match.len > 3 {
 		_, vccommit = line_to_timestamp_and_commit(vcbefore_subject_match)
 	} else {
 		scripting.verbose_trace(@FN, 'the v commit did not match anything in the vc log; try --timestamp instead.')
-		vcbefore := scripting.run('git rev-list HEAD -n1 --timestamp --before=$v_timestamp ')
+		vcbefore := scripting.run('git rev-list HEAD -n1 --timestamp --before=${v_timestamp} ')
 		_, vccommit = line_to_timestamp_and_commit(vcbefore)
 	}
-	scripting.verbose_trace(@FN, 'vccommit: $vccommit')
-	scripting.run('git checkout --quiet "$vccommit" ')
+	scripting.verbose_trace(@FN, 'vccommit: ${vccommit}')
+	scripting.run('git checkout --quiet "${vccommit}" ')
 	scripting.run('wc *.c')
 	scripting.chdir(cdir)
 	return v_commithash, vccommit
 }
 
 pub fn clone_or_pull(remote_git_url string, local_worktree_path string) {
-	// NB: after clone_or_pull, the current repo branch is === HEAD === master
+	// Note: after clone_or_pull, the current repo branch is === HEAD === master
 	if os.is_dir(local_worktree_path) && os.is_dir(os.join_path_single(local_worktree_path, '.git')) {
 		// Already existing ... Just pulling in this case is faster usually.
-		scripting.run('git -C "$local_worktree_path"  checkout --quiet master')
-		scripting.run('git -C "$local_worktree_path"  pull     --quiet ')
+		scripting.run('git -C "${local_worktree_path}"  checkout --quiet master')
+		scripting.run('git -C "${local_worktree_path}"  pull     --quiet ')
 	} else {
 		// Clone a fresh
-		scripting.run('git clone --quiet "$remote_git_url"  "$local_worktree_path" ')
+		scripting.run('git clone --quiet "${remote_git_url}"  "${local_worktree_path}" ')
 	}
 }
 
@@ -111,17 +111,17 @@ pub fn (mut vgit_context VGitContext) compile_oldv_if_needed() {
 	mut command_for_building_v_from_c_source := ''
 	mut command_for_selfbuilding := ''
 	if 'windows' == os.user_os() {
-		command_for_building_v_from_c_source = '$vgit_context.cc -std=c99 -I ./thirdparty/stdatomic/win -municode -w -o cv.exe  "$vgit_context.path_vc/v_win.c" '
-		command_for_selfbuilding = './cv.exe -o $vgit_context.vexename {SOURCE}'
+		command_for_building_v_from_c_source = '${vgit_context.cc} -std=c99 -I ./thirdparty/stdatomic/win -municode -w -o cv.exe  "${vgit_context.path_vc}/v_win.c" '
+		command_for_selfbuilding = './cv.exe -o ${vgit_context.vexename} {SOURCE}'
 	} else {
-		command_for_building_v_from_c_source = '$vgit_context.cc -std=gnu11 -I ./thirdparty/stdatomic/nix -w -o cv "$vgit_context.path_vc/v.c"  -lm -lpthread'
-		command_for_selfbuilding = './cv -o $vgit_context.vexename {SOURCE}'
+		command_for_building_v_from_c_source = '${vgit_context.cc} -std=gnu11 -I ./thirdparty/stdatomic/nix -w -o cv "${vgit_context.path_vc}/v.c"  -lm -lpthread'
+		command_for_selfbuilding = './cv -o ${vgit_context.vexename} {SOURCE}'
 	}
 	scripting.chdir(vgit_context.workdir)
 	clone_or_pull(vgit_context.v_repo_url, vgit_context.path_v)
 	clone_or_pull(vgit_context.vc_repo_url, vgit_context.path_vc)
 	scripting.chdir(vgit_context.path_v)
-	scripting.run('git checkout --quiet $vgit_context.commit_v')
+	scripting.run('git checkout --quiet ${vgit_context.commit_v}')
 	if os.is_dir(vgit_context.path_v) && os.exists(vgit_context.vexepath) {
 		// already compiled, so no need to compile v again
 		vgit_context.commit_v__hash = get_current_folder_commit_hash()
@@ -163,7 +163,7 @@ pub mut:
 
 pub fn add_common_tool_options(mut context VGitOptions, mut fp flag.FlagParser) []string {
 	tdir := os.temp_dir()
-	context.workdir = os.real_path(fp.string('workdir', `w`, context.workdir, 'A writable base folder. Default: $tdir'))
+	context.workdir = os.real_path(fp.string('workdir', `w`, context.workdir, 'A writable base folder. Default: ${tdir}'))
 	context.v_repo_url = fp.string('vrepo', 0, context.v_repo_url, 'The url of the V repository. You can clone it locally too. See also --vcrepo below.')
 	context.vc_repo_url = fp.string('vcrepo', 0, context.vc_repo_url, 'The url of the vc repository. You can clone it
 ${flag.space}beforehand, and then just give the local folder
@@ -187,7 +187,7 @@ ${flag.space}to script it/run it in a restrictive vps/docker.
 		context.vc_repo_url = os.real_path(context.vc_repo_url)
 	}
 	commits := fp.finalize() or {
-		eprintln('Error: $err')
+		eprintln('Error: ${err}')
 		exit(1)
 	}
 	for commit in commits {

cmd/tools/modules/vhelp/vhelp.v

@@ -1,14 +0,0 @@
-module vhelp
-
-import os
-
-pub fn show_topic(topic string) {
-	vexe := os.real_path(os.getenv('VEXE'))
-	vroot := os.dir(vexe)
-	target_topic := os.join_path(vroot, 'cmd', 'v', 'help', '${topic}.txt')
-	content := os.read_file(target_topic) or {
-		eprintln('Unknown topic: $topic')
-		exit(1)
-	}
-	println(content)
-}

cmd/tools/oldv.v

@@ -16,7 +16,7 @@ const (
 |          git checkout known_good_commit
 |          git bisect good
 |              ## Now git will automatically checkout a middle commit between the bad and the good
-|          cmd/tools/oldv HEAD --command="run commands in oldv folder, to verify if the commit is good or bad"
+|          cmd/tools/oldv --bisect --command="run commands in oldv folder, to verify if the commit is good or bad"
 |              ## See what the result is, and either do: ...
 |          git bisect good
 |              ## ... or do:
@@ -40,6 +40,7 @@ mut:
 	cleanup       bool   // should the tool run a cleanup first
 	use_cache     bool   // use local cached copies for --vrepo and --vcrepo in
 	fresh_tcc     bool   // do use `make fresh_tcc`
+	is_bisect     bool   // bisect mode; usage: `cmd/tools/oldv -b -c './v run bug.v'`
 }
 
 fn (mut c Context) compile_oldv_if_needed() {
@@ -56,7 +57,7 @@ fn (mut c Context) compile_oldv_if_needed() {
 	c.vgcontext.compile_oldv_if_needed()
 	c.commit_v_hash = c.vgcontext.commit_v__hash
 	if !os.exists(c.vgcontext.vexepath) && c.cmd_to_run.len > 0 {
-		// NB: 125 is a special code, that git bisect understands as 'skip this commit'.
+		// Note: 125 is a special code, that git bisect understands as 'skip this commit'.
 		// it is used to inform git bisect that the current commit leads to a build failure.
 		exit(125)
 	}
@@ -71,7 +72,7 @@ const cache_oldv_folder_vc = os.join_path(cache_oldv_folder, 'vc')
 fn sync_cache() {
 	scripting.verbose_trace(@FN, 'start')
 	if !os.exists(cache_oldv_folder) {
-		scripting.verbose_trace(@FN, 'creating $cache_oldv_folder')
+		scripting.verbose_trace(@FN, 'creating ${cache_oldv_folder}')
 		scripting.mkdir_all(cache_oldv_folder) or {
 			scripting.verbose_trace(@FN, '## failed.')
 			exit(1)
@@ -81,16 +82,16 @@ fn sync_cache() {
 	for reponame in ['v', 'vc'] {
 		repofolder := os.join_path(cache_oldv_folder, reponame)
 		if !os.exists(repofolder) {
-			scripting.verbose_trace(@FN, 'cloning to $repofolder')
-			scripting.exec('git clone --quiet https://github.com/vlang/$reponame $repofolder') or {
-				scripting.verbose_trace(@FN, '## error during clone: $err')
+			scripting.verbose_trace(@FN, 'cloning to ${repofolder}')
+			scripting.exec('git clone --quiet https://github.com/vlang/${reponame} ${repofolder}') or {
+				scripting.verbose_trace(@FN, '## error during clone: ${err}')
 				exit(1)
 			}
 		}
 		scripting.chdir(repofolder)
 		scripting.exec('git pull --quiet') or {
-			scripting.verbose_trace(@FN, 'pulling to $repofolder')
-			scripting.verbose_trace(@FN, '## error during pull: $err')
+			scripting.verbose_trace(@FN, 'pulling to ${repofolder}')
+			scripting.verbose_trace(@FN, '## error during pull: ${err}')
 			exit(1)
 		}
 	}
@@ -122,8 +123,9 @@ fn main() {
 		context.vgo.vc_repo_url = 'https://github.com/vlang/vc'
 	}
 	should_sync := fp.bool('cache-sync', `s`, false, 'Update the local cache')
-	if !should_sync {
-		fp.limit_free_args(1, 1) ?
+	context.is_bisect = fp.bool('bisect', `b`, false, 'Bisect mode. Use the current commit in the repo where oldv is.')
+	if !should_sync && !context.is_bisect {
+		fp.limit_free_args(1, 1)!
 	}
 	////
 	context.cleanup = fp.bool('clean', 0, false, 'Clean before running (slower).')
@@ -141,14 +143,18 @@ fn main() {
 	}
 	if commits.len > 0 {
 		context.commit_v = commits[0]
+		if context.is_bisect {
+			eprintln('In bisect mode, you should not pass any commits, since oldv will use the current one.')
+			exit(2)
+		}
 	} else {
 		context.commit_v = scripting.run('git rev-list -n1 HEAD')
 	}
-	scripting.cprintln('#################  context.commit_v: $context.commit_v #####################')
+	scripting.cprintln('#################  context.commit_v: ${context.commit_v} #####################')
 	context.path_v = vgit.normalized_workpath_for_commit(context.vgo.workdir, context.commit_v)
 	context.path_vc = vgit.normalized_workpath_for_commit(context.vgo.workdir, 'vc')
 	if !os.is_dir(context.vgo.workdir) {
-		eprintln('Work folder: $context.vgo.workdir , does not exist.')
+		eprintln('Work folder: ${context.vgo.workdir} , does not exist.')
 		exit(2)
 	}
 	ecc := os.getenv('CC')
@@ -162,7 +168,7 @@ fn main() {
 	context.compile_oldv_if_needed()
 	scripting.chdir(context.path_v)
 	shorter_hash := context.commit_v_hash[0..10]
-	scripting.cprintln('#     v commit hash: $shorter_hash | folder: $context.path_v')
+	scripting.cprintln('#     v commit hash: ${shorter_hash} | folder: ${context.path_v}')
 	if context.cmd_to_run.len > 0 {
 		scripting.cprintln_strong('#           command: ${context.cmd_to_run:-34s}')
 		cmdres := os.execute_or_exit(context.cmd_to_run)

cmd/tools/performance_compare.v

@@ -37,10 +37,10 @@ fn (c Context) compare_versions() {
 	// Input is validated at this point...
 	// Cleanup artifacts from previous runs of this tool:
 	scripting.chdir(c.vgo.workdir)
-	scripting.run('rm -rf "$c.a" "$c.b" "$c.vc" ')
+	scripting.run('rm -rf "${c.a}" "${c.b}" "${c.vc}" ')
 	// clone the VC source *just once per comparison*, and reuse it:
-	scripting.run('git clone --quiet "$c.vgo.vc_repo_url" "$c.vc" ')
-	println('Comparing V performance of commit $c.commit_before (before) vs commit $c.commit_after (after) ...')
+	scripting.run('git clone --quiet "${c.vgo.vc_repo_url}" "${c.vc}" ')
+	println('Comparing V performance of commit ${c.commit_before} (before) vs commit ${c.commit_after} (after) ...')
 	c.prepare_v(c.b, c.commit_before)
 	c.prepare_v(c.a, c.commit_after)
 	scripting.chdir(c.vgo.workdir)
@@ -72,7 +72,7 @@ fn (c Context) compare_versions() {
 	])
 	println('All performance files:')
 	for f in perf_files {
-		println('   $f')
+		println('   ${f}')
 	}
 }
 
@@ -92,11 +92,11 @@ fn (c &Context) prepare_v(cdir string, commit string) {
 	}
 	vgit_context.compile_oldv_if_needed()
 	scripting.chdir(cdir)
-	println('Making a v compiler in $cdir')
-	scripting.run('./v -cc $cc       -o v     $vgit_context.vvlocation')
-	println('Making a vprod compiler in $cdir')
-	scripting.run('./v -cc $cc -prod -o vprod $vgit_context.vvlocation')
-	println('Stripping and compressing cv v and vprod binaries in $cdir')
+	println('Making a v compiler in ${cdir}')
+	scripting.run('./v -cc ${cc}       -o v     ${vgit_context.vvlocation}')
+	println('Making a vprod compiler in ${cdir}')
+	scripting.run('./v -cc ${cc} -prod -o vprod ${vgit_context.vvlocation}')
+	println('Stripping and compressing cv v and vprod binaries in ${cdir}')
 	scripting.run('cp    cv     cv_stripped')
 	scripting.run('cp     v      v_stripped')
 	scripting.run('cp vprod  vprod_stripped')
@@ -107,13 +107,13 @@ fn (c &Context) prepare_v(cdir string, commit string) {
 	scripting.run('upx -qqq --lzma    cv_stripped_upxed')
 	scripting.run('upx -qqq --lzma     v_stripped_upxed')
 	scripting.run('upx -qqq --lzma vprod_stripped_upxed')
-	scripting.show_sizes_of_files(['$cdir/cv', '$cdir/cv_stripped', '$cdir/cv_stripped_upxed'])
-	scripting.show_sizes_of_files(['$cdir/v', '$cdir/v_stripped', '$cdir/v_stripped_upxed'])
-	scripting.show_sizes_of_files(['$cdir/vprod', '$cdir/vprod_stripped',
-		'$cdir/vprod_stripped_upxed'])
-	vversion := scripting.run('$cdir/v -version')
+	scripting.show_sizes_of_files(['${cdir}/cv', '${cdir}/cv_stripped', '${cdir}/cv_stripped_upxed'])
+	scripting.show_sizes_of_files(['${cdir}/v', '${cdir}/v_stripped', '${cdir}/v_stripped_upxed'])
+	scripting.show_sizes_of_files(['${cdir}/vprod', '${cdir}/vprod_stripped',
+		'${cdir}/vprod_stripped_upxed'])
+	vversion := scripting.run('${cdir}/v -version')
 	vcommit := scripting.run('git rev-parse --short  --verify HEAD')
-	println('V version is: $vversion , local source commit: $vcommit')
+	println('V version is: ${vversion} , local source commit: ${vcommit}')
 	if vgit_context.vvlocation == 'cmd/v' {
 		if os.exists('vlib/v/ast/ast.v') {
 			println('Source lines of the compiler: ' +
@@ -132,21 +132,21 @@ fn (c &Context) prepare_v(cdir string, commit string) {
 
 fn (c Context) compare_v_performance(label string, commands []string) string {
 	println('---------------------------------------------------------------------------------')
-	println('Compare v performance when doing the following commands ($label):')
+	println('Compare v performance when doing the following commands (${label}):')
 	mut source_location_a := ''
 	mut source_location_b := ''
-	if os.exists('$c.a/cmd/v') {
+	if os.exists('${c.a}/cmd/v') {
 		source_location_a = 'cmd/v'
 	} else {
-		source_location_a = if os.exists('$c.a/v.v') { 'v.v       ' } else { 'compiler/ ' }
+		source_location_a = if os.exists('${c.a}/v.v') { 'v.v       ' } else { 'compiler/ ' }
 	}
-	if os.exists('$c.b/cmd/v') {
+	if os.exists('${c.b}/cmd/v') {
 		source_location_b = 'cmd/v'
 	} else {
-		source_location_b = if os.exists('$c.b/v.v') { 'v.v       ' } else { 'compiler/ ' }
+		source_location_b = if os.exists('${c.b}/v.v') { 'v.v       ' } else { 'compiler/ ' }
 	}
-	timestamp_a, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd $c.a/ ; git rev-list -n1 --timestamp HEAD'))
-	timestamp_b, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd $c.b/ ; git rev-list -n1 --timestamp HEAD'))
+	timestamp_a, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd ${c.a}/ ; git rev-list -n1 --timestamp HEAD'))
+	timestamp_b, _ := vgit.line_to_timestamp_and_commit(scripting.run('cd ${c.b}/ ; git rev-list -n1 --timestamp HEAD'))
 	debug_option_a := if timestamp_a > 1570877641 { '-cg    ' } else { '-debug ' }
 	debug_option_b := if timestamp_b > 1570877641 { '-cg    ' } else { '-debug ' }
 	mut hyperfine_commands_arguments := []string{}
@@ -154,7 +154,7 @@ fn (c Context) compare_v_performance(label string, commands []string) string {
 		println(cmd)
 	}
 	for cmd in commands {
-		hyperfine_commands_arguments << ' \'cd ${c.b:-34s} ; ./$cmd \' '.replace_each([
+		hyperfine_commands_arguments << ' \'cd ${c.b:-34s} ; ./${cmd} \' '.replace_each([
 			'@COMPILER@',
 			source_location_b,
 			'@DEBUG@',
@@ -162,7 +162,7 @@ fn (c Context) compare_v_performance(label string, commands []string) string {
 		])
 	}
 	for cmd in commands {
-		hyperfine_commands_arguments << ' \'cd ${c.a:-34s} ; ./$cmd \' '.replace_each([
+		hyperfine_commands_arguments << ' \'cd ${c.a:-34s} ; ./${cmd} \' '.replace_each([
 			'@COMPILER@',
 			source_location_a,
 			'@DEBUG@',
@@ -171,15 +171,15 @@ fn (c Context) compare_v_performance(label string, commands []string) string {
 	}
 	// /////////////////////////////////////////////////////////////////////////////
 	cmd_stats_file := os.real_path([c.vgo.workdir, 'v_performance_stats_${label}.json'].join(os.path_separator))
-	comparison_cmd := 'hyperfine $c.hyperfineopts ' + '--export-json $cmd_stats_file ' +
-		'--time-unit millisecond ' + '--style full --warmup $c.warmups ' +
+	comparison_cmd := 'hyperfine ${c.hyperfineopts} ' + '--export-json ${cmd_stats_file} ' +
+		'--time-unit millisecond ' + '--style full --warmup ${c.warmups} ' +
 		hyperfine_commands_arguments.join(' ')
 	// /////////////////////////////////////////////////////////////////////////////
 	if c.vgo.verbose {
 		println(comparison_cmd)
 	}
 	os.system(comparison_cmd)
-	println('The detailed performance comparison report was saved to: $cmd_stats_file .')
+	println('The detailed performance comparison report was saved to: ${cmd_stats_file} .')
 	println('')
 	return cmd_stats_file
 }
@@ -194,11 +194,11 @@ fn main() {
 	fp.description(tool_description)
 	fp.arguments_description('COMMIT_BEFORE [COMMIT_AFTER]')
 	fp.skip_executable()
-	fp.limit_free_args(1, 2) ?
+	fp.limit_free_args(1, 2)!
 	context.vflags = fp.string('vflags', 0, '', 'Additional options to pass to the v commands, for example "-cc tcc"')
 	context.hyperfineopts = fp.string('hyperfine_options', 0, '', 'Additional options passed to hyperfine.
 ${flag.space}For example on linux, you may want to pass:
-$flag.space--hyperfine_options "--prepare \'sync; echo 3 | sudo tee /proc/sys/vm/drop_caches\'"
+${flag.space}--hyperfine_options "--prepare \'sync; echo 3 | sudo tee /proc/sys/vm/drop_caches\'"
 ')
 	commits := vgit.add_common_tool_options(mut context.vgo, mut fp)
 	context.commit_before = commits[0]

cmd/tools/regress.v

@@ -0,0 +1,79 @@
+import os
+import term
+import flag
+
+const tools_folder = os.real_path(os.dir(os.executable()))
+
+const oldvexe = fullpath(tools_folder, 'oldv')
+
+const oldv_source = fullpath(tools_folder, 'oldv.v')
+
+const vroot = os.real_path(os.dir(os.dir(tools_folder)))
+
+const vexe = fullpath(vroot, 'v')
+
+fn fullpath(folder string, fname string) string {
+	return os.real_path(os.join_path_single(folder, exename(fname)))
+}
+
+fn exename(n string) string {
+	if n.ends_with('.v') || os.user_os() != 'windows' {
+		return n
+	}
+	return '${n}.exe'
+}
+
+struct Context {
+mut:
+	old_commit string
+	new_commit string
+	command    string
+}
+
+fn main() {
+	mut fp := flag.new_flag_parser(os.args)
+	mut context := Context{}
+	fp.application(os.file_name(os.executable()))
+	fp.version('0.0.2')
+	fp.description('\n  Find at what commit a regression occurred.
+  To find when a regression happened (regression_bug.v should fail on master):
+     ./v run cmd/tools/regress.v --old a7019ac --command "  ./v run /abs/path/to/regression_bug.v"
+  To find when a feature was implemented (feature.v should succeed on master):
+     ./v run cmd/tools/regress.v --old a7019ac --command "! ./v run /abs/path/to/feature.v"')
+	fp.skip_executable()
+	//
+	context.new_commit = fp.string('new', `n`, 'master', 'The new commit, by default: master.')
+	context.old_commit = fp.string('old', `o`, '', 'A known old commit, required (for it, COMMAND should exit with 0).')
+	context.command = fp.string('command', `c`, '', 'A command to execute. Should exit with 0 for the *old* commits.')
+	fp.finalize() or {}
+	if context.old_commit == '' {
+		eprintln('--old COMMIT is required')
+		exit(1)
+	}
+	if context.command == '' {
+		eprintln('--command "COMMAND" is required')
+		exit(2)
+	}
+	if !os.exists(oldvexe) {
+		if 0 != execute('${os.quoted_path(vexe)} -o ${os.quoted_path(oldvexe)} ${os.quoted_path(oldv_source)}') {
+			panic('can not compile ${oldvexe}')
+		}
+	}
+	os.execute('git checkout master')
+	os.execute('git bisect reset')
+	os.execute('git checkout ${context.new_commit}')
+	os.execute('git bisect start')
+	os.execute('git bisect new')
+	os.execute('git checkout ${context.old_commit}')
+	os.execute('git bisect old')
+	println(term.colorize(term.bright_yellow, term.header('', '-')))
+	execute('git bisect run ${os.quoted_path(oldvexe)} --bisect -c "${context.command}"')
+	println(term.colorize(term.bright_yellow, term.header('', '-')))
+	os.execute('git bisect reset')
+	os.execute('git checkout master')
+}
+
+fn execute(cmd string) int {
+	eprintln('### ${cmd}')
+	return os.system(cmd)
+}

cmd/tools/repeat.v

@@ -143,25 +143,25 @@ const (
 
 fn main() {
 	mut context := Context{}
-	context.parse_options() ?
+	context.parse_options()!
 	context.run()
 	context.show_diff_summary()
 }
 
-fn (mut context Context) parse_options() ? {
+fn (mut context Context) parse_options() ! {
 	mut fp := flag.new_flag_parser(os.args)
 	fp.application(os.file_name(os.executable()))
 	fp.version('0.0.1')
-	fp.description('Repeat command(s) and collect statistics. NB: you have to quote each command, if it contains spaces.')
+	fp.description('Repeat command(s) and collect statistics. Note: you have to quote each command, if it contains spaces.')
 	fp.arguments_description('CMD1 CMD2 ...')
 	fp.skip_executable()
-	fp.limit_free_args_to_at_least(1) ?
+	fp.limit_free_args_to_at_least(1)!
 	context.count = fp.int('count', `c`, 10, 'Repetition count.')
 	context.series = fp.int('series', `s`, 2, 'Series count. `-s 2 -c 4 a b` => aaaabbbbaaaabbbb, while `-s 3 -c 2 a b` => aabbaabbaabb.')
 	context.warmup = fp.int('warmup', `w`, 2, 'Warmup runs. These are done *only at the start*, and are ignored.')
 	context.show_help = fp.bool('help', `h`, false, 'Show this help screen.')
 	context.use_newline = fp.bool('newline', `n`, false, 'Use \\n, do not overwrite the last line. Produces more output, but easier to diagnose.')
-	context.show_output = fp.bool('output', `O`, false, 'Show command stdout/stderr in the progress indicator for each command. NB: slower, for verbose commands.')
+	context.show_output = fp.bool('output', `O`, false, 'Show command stdout/stderr in the progress indicator for each command. Note: slower, for verbose commands.')
 	context.verbose = fp.bool('verbose', `v`, false, 'Be more verbose.')
 	context.fail_on_maxtime = fp.int('max_time', `m`, max_time, 'Fail with exit code 2, when first cmd takes above M milliseconds (regression).')
 	context.fail_on_regress_percent = fp.int('fail_percent', `f`, max_fail_percent, 'Fail with exit code 3, when first cmd is X% slower than the rest (regression).')
@@ -183,7 +183,7 @@ fn (mut context Context) parse_options() ? {
 		scripting.set_verbose(true)
 	}
 	commands := fp.finalize() or {
-		eprintln('Error: $err')
+		eprintln('Error: ${err}')
 		exit(1)
 	}
 	context.commands = context.expand_all_commands(commands)
@@ -200,8 +200,13 @@ fn (mut context Context) parse_options() ? {
 	}
 }
 
+fn flushed_print(s string) {
+	print(s)
+	flush_stdout()
+}
+
 fn (mut context Context) clear_line() {
-	print(context.cline)
+	flushed_print(context.cline)
 }
 
 fn (mut context Context) expand_all_commands(commands []string) []string {
@@ -244,10 +249,10 @@ fn (mut context Context) run() {
 			mut duration := 0
 			mut sum := 0
 			mut oldres := ''
-			println('Series: ${si:4}/${context.series:-4}, command: $cmd')
+			println('Series: ${si:4}/${context.series:-4}, command: ${cmd}')
 			if context.warmup > 0 && run_warmups < context.commands.len {
 				for i in 1 .. context.warmup + 1 {
-					print('${context.cgoback}warming up run: ${i:4}/${context.warmup:-4} for ${cmd:-50s} took ${duration:6} ms ...')
+					flushed_print('${context.cgoback}warming up run: ${i:4}/${context.warmup:-4} for ${cmd:-50s} took ${duration:6} ms ...')
 					mut sw := time.new_stopwatch()
 					res := os.execute(cmd)
 					if res.exit_code != 0 {
@@ -260,15 +265,15 @@ fn (mut context Context) run() {
 			context.clear_line()
 			for i in 1 .. (context.count + 1) {
 				avg := f64(sum) / f64(i)
-				print('${context.cgoback}Average: ${avg:9.3f}ms | run: ${i:4}/${context.count:-4} | took ${duration:6} ms')
+				flushed_print('${context.cgoback}Average: ${avg:9.3f}ms | run: ${i:4}/${context.count:-4} | took ${duration:6} ms')
 				if context.show_output {
-					print(' | result: ${oldres:s}')
+					flushed_print(' | result: ${oldres:s}')
 				}
 				mut sw := time.new_stopwatch()
 				res := scripting.exec(cmd) or { continue }
 				duration = int(sw.elapsed().milliseconds())
 				if res.exit_code != 0 {
-					eprintln('${i:10} non 0 exit code for cmd: $cmd')
+					eprintln('${i:10} non 0 exit code for cmd: ${cmd}')
 					continue
 				}
 				trimed_output := res.output.trim_right('\r\n')
@@ -288,7 +293,7 @@ fn (mut context Context) run() {
 			context.results[icmd].atiming = new_aints(context.results[icmd].timings, context.nmins,
 				context.nmaxs)
 			context.clear_line()
-			print(context.cgoback)
+			flushed_print(context.cgoback)
 			mut m := map[string][]int{}
 			ioutputs := context.results[icmd].outputs
 			for o in ioutputs {
@@ -303,7 +308,7 @@ fn (mut context Context) run() {
 			for k, v in m {
 				// show a temporary summary for the current series/cmd cycle
 				s := new_aints(v, context.nmins, context.nmaxs)
-				println('  $k: $s')
+				println('  ${k}: ${s}')
 				summary[k] = s
 			}
 			// merge current raw results to the previous ones
@@ -341,7 +346,7 @@ fn (mut context Context) show_diff_summary() {
 		}
 		return 0
 	})
-	println('Summary (commands are ordered by ascending mean time), after $context.series series of $context.count repetitions:')
+	println('Summary (commands are ordered by ascending mean time), after ${context.series} series of ${context.count} repetitions:')
 	base := context.results[0].atiming.average
 	mut first_cmd_percentage := f64(100.0)
 	mut first_marker := ''
@@ -352,14 +357,14 @@ fn (mut context Context) show_diff_summary() {
 			first_marker = bold('>')
 			first_cmd_percentage = cpercent
 		}
-		println(' $first_marker${(i + 1):3} | ${cpercent:5.1f}% slower | ${r.cmd:-57s} | $r.atiming')
+		println(' ${first_marker}${(i + 1):3} | ${cpercent:5.1f}% slower | ${r.cmd:-57s} | ${r.atiming}')
 	}
 	$if debugcontext ? {
-		println('context: $context')
+		println('context: ${context}')
 	}
 	if int(base) > context.fail_on_maxtime {
-		print(performance_regression_label)
-		println('average time: ${base:6.1f} ms > $context.fail_on_maxtime ms threshold.')
+		flushed_print(performance_regression_label)
+		println('average time: ${base:6.1f} ms > ${context.fail_on_maxtime} ms threshold.')
 		exit(2)
 	}
 	if context.fail_on_regress_percent == max_fail_percent || context.results.len < 2 {
@@ -367,7 +372,7 @@ fn (mut context Context) show_diff_summary() {
 	}
 	fail_threshold_max := f64(context.fail_on_regress_percent)
 	if first_cmd_percentage > fail_threshold_max {
-		print(performance_regression_label)
+		flushed_print(performance_regression_label)
 		println('${first_cmd_percentage:5.1f}% > ${fail_threshold_max:5.1f}% threshold.')
 		exit(3)
 	}

cmd/tools/report_v_module_folders_without_tests.v

@@ -0,0 +1,68 @@
+module main
+
+import os
+
+const vexe = @VEXE
+
+const known_skip_patterns_env = os.getenv('VKNOWN_SKIP_PATTERNS')
+
+const known_folder_patterns_that_are_not_module_ones = [
+	'vlib/sync/bench',
+	'/tests',
+	'/testdata',
+	'/preludes_js',
+	'vlib/builtin/js', // TODO: fix compiler panic
+	'vlib/fontstash', // used by `gg`
+	'vlib/sokol/sfons', // used by `gg`, and by examples/sokol/fonts.v
+	'vlib/sokol/sapp', // used by `gg`, and many examples/
+	'vlib/sokol/gfx', // used by `gg`, `x.ttf`
+	'vlib/sokol/sgl', // used by `gg`
+	'vlib/toml', // toml is well tested, even if the top level folder does not have _test.v files, the ones below do
+	'vlib/v/', // the compiler itself is well tested
+]
+
+fn main() {
+	mut places := if os.args.len > 1 {
+		os.args#[1..]
+	} else {
+		eprintln('> check the current folder only by default ...')
+		['.']
+	}
+	mut known_skip_patterns := known_folder_patterns_that_are_not_module_ones.clone()
+	if known_skip_patterns_env != '' {
+		known_skip_patterns = known_skip_patterns_env.split(',').filter(it != '')
+	}
+	for path in places {
+		eprintln('> Checking folder: `${path}` ...')
+		mut found := 0
+		files := os.walk_ext(path, '.v')
+		mut v_files := map[string]int{}
+		mut v_test_files := map[string]int{}
+		for f in files {
+			folder := os.to_slash(os.dir(f))
+			if known_skip_patterns.any(f.contains(it)) {
+				continue
+			}
+			if f.ends_with('.v') {
+				v_files[folder]++
+			}
+			if f.ends_with('_test.v') {
+				v_test_files[folder]++
+			}
+		}
+		eprintln('> Found ${v_files.len:5} potential V module folders (containing .v files).')
+		for folder, n_v_files in v_files {
+			n_test_v_files := v_test_files[folder]
+			if n_v_files > 1 && n_test_v_files == 0 {
+				println('> ${n_test_v_files:5} _test.v files, with ${n_v_files:5} .v files, in folder: ${folder}')
+				compilation := os.execute('${os.quoted_path(vexe)} -shared -W -Wfatal-errors -check ${os.quoted_path(folder)}')
+				if compilation.exit_code != 0 {
+					eprintln('> ${folder} has parser/checker errors!')
+					eprintln(compilation.output)
+				}
+				found++
+			}
+		}
+		eprintln('> Found ${found} module folders without _test.v files in `${path}` .')
+	}
+}

cmd/tools/test_if_v_test_system_works.v

@@ -6,7 +6,7 @@ import os
 import rand
 
 const (
-	vexe  = get_vexe_path()
+	vexe  = os.quoted_path(get_vexe_path())
 	vroot = os.dir(vexe)
 	tdir  = new_tdir()
 )
@@ -17,7 +17,7 @@ fn get_vexe_path() string {
 		return env_vexe
 	}
 	me := os.executable()
-	eprintln('me: $me')
+	eprintln('me: ${me}')
 	mut vexe_ := os.join_path(os.dir(os.dir(os.dir(me))), 'v')
 	if os.user_os() == 'windows' {
 		vexe_ += '.exe'
@@ -26,63 +26,110 @@ fn get_vexe_path() string {
 }
 
 fn new_tdir() string {
-	tdir_ := os.join_path(os.temp_dir(), rand.ulid())
-	if os.exists(tdir_) {
-		os.rmdir(tdir_) or { panic(err) }
-	}
-	os.mkdir(tdir_) or { panic(err) }
+	dir := os.join_path(os.vtmp_dir(), 'v', rand.ulid())
+	os.rmdir_all(dir) or {}
+	os.mkdir_all(dir) or { panic(err) }
 	C.atexit(cleanup_tdir)
-	return tdir_
+	return dir
 }
 
 fn cleanup_tdir() {
-	println('... removing tdir: $tdir')
+	println('... removing tdir: ${tdir}')
 	os.rmdir_all(tdir) or { eprintln(err) }
 }
 
-fn create_test(tname string, tcontent string) ?string {
+type MyResult = string
+
+[noreturn]
+fn (result MyResult) fail(reason string) {
+	eprintln('> ${reason}, but it does not. Result:\n${result}')
+	exit(1)
+}
+
+fn (result MyResult) has(sub string) MyResult {
+	if !result.contains(sub) {
+		result.fail(' result should have the substring `${sub}`')
+	}
+	return result
+}
+
+fn (result MyResult) matches(gpattern string) MyResult {
+	if !result.match_glob(gpattern) {
+		result.fail('result should match the glob pattern `${gpattern}`')
+	}
+	return result
+}
+
+fn create_test(tname string, tcontent string) !string {
 	tpath := os.join_path(tdir, tname)
-	os.write_file(tpath, tcontent) ?
-	eprintln('>>>>>>>> tpath: $tpath | tcontent: $tcontent')
-	return tpath
+	os.write_file(tpath, tcontent)!
+	eprintln('>>>>>>>> tpath: ${tpath} | tcontent: ${tcontent}')
+	return os.quoted_path(tpath)
+}
+
+fn check_assert_continues_works() ! {
+	os.chdir(tdir)!
+	create_test('assert_continues_option_works_test.v', 'fn test_fail1() { assert 2==4\nassert 2==1\nassert 2==0 }\nfn test_ok(){ assert true }\nfn test_fail2() { assert false }')!
+	result := check_fail('${vexe} -assert continues assert_continues_option_works_test.v')
+	result.has('assert_continues_option_works_test.v:1: fn test_fail1')
+	result.has('assert_continues_option_works_test.v:2: fn test_fail1')
+	result.has('assert_continues_option_works_test.v:3: fn test_fail1')
+	result.has('assert_continues_option_works_test.v:5: fn test_fail2')
+	result.has('> assert 2 == 4').has('> assert 2 == 1').has('> assert 2 == 0')
+	// Check if a test function, tagged with [assert_continues], has the same behaviour, without needing additional options
+	create_test('assert_continues_tag_works_test.v', '[assert_continues]fn test_fail1() { assert 2==4\nassert 2==1\nassert 2==0 }\nfn test_ok(){ assert true }\nfn test_fail2() { assert false\n assert false }')!
+	tag_res := check_fail('${vexe} assert_continues_tag_works_test.v')
+	tag_res.has('assert_continues_tag_works_test.v:1: fn test_fail1')
+	tag_res.has('assert_continues_tag_works_test.v:2: fn test_fail1')
+	tag_res.has('assert_continues_tag_works_test.v:3: fn test_fail1')
+	tag_res.has('assert_continues_tag_works_test.v:5: fn test_fail2')
+	if tag_res.contains('assert_continues_tag_works_test.v:6: fn test_fail2') {
+		exit(1)
+	}
+}
+
+fn check_ok(cmd string) MyResult {
+	println('>   check_ok cmd: ${cmd}')
+	res := os.execute(cmd)
+	if res.exit_code != 0 {
+		eprintln('>   check_ok failed.\n${res.output}')
+		exit(1)
+	}
+	return res.output
+}
+
+fn check_fail(cmd string) MyResult {
+	println('> check_fail cmd: ${cmd}')
+	res := os.execute(cmd)
+	if res.exit_code == 0 {
+		eprintln('> check_fail succeeded, but it should have failed.\n${res.output}')
+		exit(1)
+	}
+	return res.output
 }
 
 fn main() {
 	defer {
 		os.chdir(os.wd_at_startup) or {}
 	}
-	println('> vroot: $vroot | vexe: $vexe | tdir: $tdir')
-	ok_fpath := create_test('a_single_ok_test.v', 'fn test_ok(){ assert true }') ?
-	check_ok('"$vexe" "$ok_fpath"')
-	check_ok('"$vexe" test "$ok_fpath"')
-	check_ok('"$vexe" test "$tdir"')
-	fail_fpath := create_test('a_single_failing_test.v', 'fn test_fail(){ assert 1 == 2 }') ?
-	check_fail('"$vexe" "$fail_fpath"')
-	check_fail('"$vexe" test "$fail_fpath"')
-	check_fail('"$vexe" test "$tdir"')
+	println('> vroot: ${vroot} | vexe: ${vexe} | tdir: ${tdir}')
+	ok_fpath := create_test('a_single_ok_test.v', 'fn test_ok(){ assert true }')!
+	if check_ok('${vexe} ${ok_fpath}') != '' {
+		exit(1)
+	}
+	check_ok('${vexe} test ${ok_fpath}').matches('*OK*a_single_ok_test.v*')
+	check_ok('${vexe} test "${tdir}"').matches('*OK*a_single_ok_test.v*')
+	//
+	fail_fpath := create_test('a_single_failing_test.v', 'fn test_fail(){ assert 1 == 2 }')!
+	check_fail('${vexe} ${fail_fpath}').has('> assert 1 == 2').has('a_single_failing_test.v:1: fn test_fail')
+	check_fail('${vexe} test ${fail_fpath}').has('> assert 1 == 2').has('a_single_failing_test.v:1: fn test_fail')
+	check_fail('${vexe} test "${tdir}"').has('> assert 1 == 2')
 	rel_dir := os.join_path(tdir, rand.ulid())
-	os.mkdir(rel_dir) ?
-	os.chdir(rel_dir) ?
-	check_ok('"$vexe" test "..${os.path_separator + os.base(ok_fpath)}"')
+	os.mkdir(rel_dir)!
+	os.chdir(rel_dir)!
+	relative_path := '..' + os.path_separator + 'a_single_ok_test.v'
+	check_ok('${vexe} test ${os.quoted_path(relative_path)}').has('OK').has('a_single_ok_test.v')
+	//
+	check_assert_continues_works()!
 	println('> all done')
 }
-
-fn check_ok(cmd string) string {
-	println('>   check_ok cmd: $cmd')
-	res := os.execute(cmd)
-	if res.exit_code != 0 {
-		eprintln('>   check_ok failed.\n$res.output')
-		exit(1)
-	}
-	return res.output
-}
-
-fn check_fail(cmd string) string {
-	println('> check_fail cmd: $cmd')
-	res := os.execute(cmd)
-	if res.exit_code == 0 {
-		eprintln('> check_fail succeeded, but it should have failed.\n$res.output')
-		exit(1)
-	}
-	return res.output
-}

cmd/tools/test_os_process.v

@@ -28,6 +28,8 @@ mut:
 	target     Target
 	omode      Target
 	is_verbose bool
+	show_wd    bool
+	show_env   bool
 }
 
 fn (mut ctx Context) println(s string) {
@@ -35,10 +37,10 @@ fn (mut ctx Context) println(s string) {
 		ctx.omode = if ctx.omode == .stderr { Target.stdout } else { Target.stderr }
 	}
 	if ctx.target in [.both, .stdout] || ctx.omode == .stdout {
-		println('stdout, $s')
+		println('stdout, ${s}')
 	}
 	if ctx.target in [.both, .stderr] || ctx.omode == .stderr {
-		eprintln('stderr, $s')
+		eprintln('stderr, ${s}')
 	}
 }
 
@@ -53,7 +55,7 @@ fn main() {
 	args := os.args[1..]
 	if '-h' in args || '--help' in args {
 		println("Usage:
-	test_os_process [-v] [-h] [-target stderr/stdout/both/alternate] [-exitcode 0] [-timeout_ms 200] [-period_ms 50]
+	test_os_process [-v] [-h] [-target stderr/stdout/both/alternate] [-show_wd] [-show_env] [-exitcode 0] [-timeout_ms 200] [-period_ms 50]
 		Prints lines periodically (-period_ms), to stdout/stderr (-target).
 		After a while (-timeout_ms), exit with (-exitcode).
 		This program is useful for platform independent testing
@@ -63,6 +65,8 @@ fn main() {
 		return
 	}
 	ctx.is_verbose = '-v' in args
+	ctx.show_wd = '-show_wd' in args
+	ctx.show_env = '-show_env' in args
 	ctx.target = s2target(cmdline.option(args, '-target', 'both'))
 	ctx.exitcode = cmdline.option(args, '-exitcode', '0').int()
 	ctx.timeout_ms = cmdline.option(args, '-timeout_ms', '200').int()
@@ -71,11 +75,20 @@ fn main() {
 		ctx.omode = .stdout
 	}
 	if ctx.is_verbose {
-		eprintln('> args: $args | context: $ctx')
+		eprintln('> args: ${args} | context: ${ctx}')
 	}
-	go do_timeout(&ctx)
+	if ctx.show_wd {
+		ctx.println('WORK_DIR=${os.getwd()}')
+	}
+	if ctx.show_env {
+		all := os.environ()
+		for k, v in all {
+			ctx.println('${k}=${v}')
+		}
+	}
+	spawn do_timeout(&ctx)
 	for i := 1; true; i++ {
-		ctx.println('$i')
+		ctx.println('${i}')
 		time.sleep(ctx.period_ms * time.millisecond)
 	}
 	time.sleep(100 * time.second)

cmd/tools/translate.v

@@ -0,0 +1,53 @@
+// Copyright (c) 2019-2023 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
+module main
+
+import os
+import v.util
+
+const vexe = os.getenv('VEXE')
+
+fn main() {
+	vmodules := os.vmodules_dir()
+	c2v_dir := os.join_path(vmodules, 'c2v')
+	mut c2v_bin := os.join_path(c2v_dir, 'c2v')
+	$if windows {
+		c2v_bin += '.exe'
+	}
+	// Git clone c2v
+	if !os.exists(c2v_dir) {
+		os.mkdir_all(vmodules)!
+		println('C2V is not installed. Cloning C2V to ${c2v_dir} ...')
+		os.chdir(vmodules)!
+		res := os.execute('git clone https://github.com/vlang/c2v')
+		if res.exit_code != 0 {
+			eprintln('Failed to download C2V.')
+			exit(1)
+		}
+	}
+	// Compile c2v
+	if !os.exists(c2v_bin) {
+		os.chdir(c2v_dir)!
+		println('Compiling c2v ...')
+		res2 := os.execute('${os.quoted_path(vexe)} -o ${os.quoted_path(c2v_bin)} -keepc -g -experimental .')
+		if res2.exit_code != 0 {
+			eprintln(res2.output)
+			eprintln('Failed to compile C2V. This should not happen. Please report it via GitHub.')
+			exit(2)
+		}
+	}
+	if os.args.len < 3 {
+		eprintln('Wrong number of arguments. Use `v translate file.c` .')
+		exit(3)
+	}
+	passed_args := util.args_quote_paths(os.args[2..])
+	// println(passed_args)
+	os.chdir(os.wd_at_startup)!
+	c2v_cmd := '${os.quoted_path(c2v_bin)} ${passed_args}'
+	res := os.system(c2v_cmd)
+	if res != 0 {
+		eprintln('C2V command: ${c2v_cmd}')
+		eprintln('C2V failed to translate the C files. Please report it via GitHub.')
+		exit(4)
+	}
+}

cmd/tools/vast/cjson.v

@@ -24,7 +24,7 @@ fn C.cJSON_CreateNull() &C.cJSON
 
 // fn C.cJSON_CreateNumber() &C.cJSON
 // fn C.cJSON_CreateString() &C.cJSON
-fn C.cJSON_CreateRaw(&byte) &C.cJSON
+fn C.cJSON_CreateRaw(&u8) &C.cJSON
 
 fn C.cJSON_IsInvalid(voidptr) bool
 
@@ -45,13 +45,13 @@ fn C.cJSON_IsObject(voidptr) bool
 
 fn C.cJSON_IsRaw(voidptr) bool
 
-fn C.cJSON_AddItemToObject(voidptr, &byte, voidptr)
+fn C.cJSON_AddItemToObject(voidptr, &u8, voidptr)
 
 fn C.cJSON_AddItemToArray(voidptr, voidptr)
 
 fn C.cJSON_Delete(voidptr)
 
-fn C.cJSON_Print(voidptr) &byte
+fn C.cJSON_Print(voidptr) &u8
 
 [inline]
 fn create_object() &C.cJSON {
@@ -108,7 +108,7 @@ fn add_item_to_array(obj &C.cJSON, item &C.cJSON) {
 	C.cJSON_AddItemToArray(obj, item)
 }
 
-fn json_print(json &C.cJSON) string {
-	s := C.cJSON_Print(json)
+fn json_print(json_ &C.cJSON) string {
+	s := C.cJSON_Print(json_)
 	return unsafe { tos3(s) }
 }

cmd/tools/vast/test/demo.v

@@ -109,23 +109,23 @@ fn defer_fn() {
 }
 
 // generic function
-fn g_fn<T>(p T) T {
+fn g_fn[T](p T) T {
 	return p
 }
 
 // generic struct
-struct GenericStruct<T> {
+struct GenericStruct[T] {
 	point Point
 mut:
 	model T
 }
 
 // generic interface
-interface Gettable<T> {
+interface Gettable[T] {
 	get() T
 }
 
 // generic sumtype
 struct None {}
 
-type MyOption<T> = Error | None | T
+type MyOption[T] = Error | None | T

cmd/tools/vast/vast.v

@@ -44,7 +44,7 @@ fn main() {
 	for hf in hfields.split(',') {
 		ctx.hide_names[hf] = true
 	}
-	fp.limit_free_args_to_at_least(1) ?
+	fp.limit_free_args_to_at_least(1)!
 	rest_of_args := fp.remaining_parameters()
 	for vfile in rest_of_args {
 		file := get_abs_path(vfile)
@@ -60,7 +60,7 @@ fn (ctx Context) write_file_or_print(file string) {
 	if ctx.is_print {
 		println(json(file))
 	} else {
-		println('$time.now(): AST written to: ' + json_file(file))
+		println('${time.now()}: AST written to: ' + json_file(file))
 	}
 }
 
@@ -74,7 +74,7 @@ fn (ctx Context) watch_for_changes(file string) {
 			ctx.write_file_or_print(file)
 			if ctx.is_compile {
 				file_name := file[0..(file.len - os.file_ext(file).len)]
-				os.system('v -o ${file_name}.c $file')
+				os.system('v -o ${file_name}.c ${file}')
 			}
 		}
 		timestamp = new_timestamp
@@ -96,11 +96,11 @@ fn get_abs_path(path string) string {
 // check file is v file and exists
 fn check_file(file string) {
 	if os.file_ext(file) !in ['.v', '.vv', '.vsh'] {
-		eprintln('the file `$file` must be a v file or vsh file')
+		eprintln('the file `${file}` must be a v file or vsh file')
 		exit(1)
 	}
 	if !os.exists(file) {
-		eprintln('the v file `$file` does not exist')
+		eprintln('the v file `${file}` does not exist')
 		exit(1)
 	}
 }
@@ -120,15 +120,15 @@ fn json(file string) string {
 	// use as permissive preferences as possible, so that `v ast`
 	// can print the AST of arbitrary V files, even .vsh or ones
 	// that require globals:
-	mut pref := &pref.Preferences{}
-	pref.fill_with_defaults()
-	pref.enable_globals = true
-	pref.is_fmt = true
+	mut pref_ := &pref.Preferences{}
+	pref_.fill_with_defaults()
+	pref_.enable_globals = true
+	pref_.is_fmt = true
 	//
 	mut t := Tree{
 		root: new_object()
 		table: ast.new_table()
-		pref: pref
+		pref: pref_
 	}
 	// parse file with comment
 	ast_file := parser.parse_file(file, t.table, .parse_comments, t.pref)
@@ -140,8 +140,8 @@ fn json(file string) string {
 
 // the ast tree
 struct Tree {
-	table &ast.Table
-	pref  &pref.Preferences
+	table &ast.Table        = unsafe { nil }
+	pref  &pref.Preferences = unsafe { nil }
 mut:
 	root Node // the root of tree
 }
@@ -224,12 +224,12 @@ fn (t Tree) type_node(typ ast.Type) &Node {
 
 // token type node
 fn (t Tree) token_node(tok_kind token.Kind) &Node {
-	return t.string_node('token:${int(tok_kind)}($tok_kind.str())')
+	return t.string_node('token:${int(tok_kind)}(${tok_kind.str()})')
 }
 
 // enum type node
-fn (t Tree) enum_node<T>(value T) &Node {
-	return t.string_node('enum:${int(value)}($value)')
+fn (t Tree) enum_node[T](value T) &Node {
+	return t.string_node('enum:${int(value)}(${value})')
 }
 
 // for [][]comment
@@ -283,7 +283,7 @@ fn (t Tree) embed_file(node ast.EmbeddedFile) &Node {
 	obj.add('compression_type', t.string_node(node.compression_type))
 	obj.add('is_compressed', t.bool_node(node.is_compressed))
 	obj.add('len', t.number_node(node.len))
-	obj.add('bytes', t.array_node_byte(node.bytes))
+	obj.add('bytes', t.array_node_u8(node.bytes))
 	return obj
 }
 
@@ -359,15 +359,14 @@ fn (t Tree) imports(nodes []ast.Import) &Node {
 	return import_array
 }
 
-fn (t Tree) errors(errors []errors.Error) &Node {
+fn (t Tree) errors(errors_ []errors.Error) &Node {
 	mut errs := new_array()
-	for e in errors {
+	for e in errors_ {
 		obj := new_object()
 		obj.add_terse('message', t.string_node(e.message))
 		obj.add_terse('file_path', t.string_node(e.file_path))
 		obj.add('pos', t.pos(e.pos))
-		obj.add_terse('backtrace', t.string_node(e.backtrace))
-		obj.add_terse('reporter', t.enum_node(e.reporter))
+		obj.add('reporter', t.enum_node(e.reporter))
 		errs.add_item(obj)
 	}
 	return errs
@@ -377,8 +376,8 @@ fn (t Tree) warnings(warnings []errors.Warning) &Node {
 	mut warns := new_array()
 	for w in warnings {
 		mut obj := new_object()
-		obj.add('message', t.string_node(w.message))
-		obj.add('file_path', t.string_node(w.file_path))
+		obj.add_terse('message', t.string_node(w.message))
+		obj.add_terse('file_path', t.string_node(w.file_path))
 		obj.add('pos', t.pos(w.pos))
 		obj.add('reporter', t.enum_node(w.reporter))
 		warns.add_item(obj)
@@ -390,8 +389,8 @@ fn (t Tree) notices(notices []errors.Notice) &Node {
 	mut notice_array := new_array()
 	for n in notices {
 		mut obj := new_object()
-		obj.add('message', t.string_node(n.message))
-		obj.add('file_path', t.string_node(n.file_path))
+		obj.add_terse('message', t.string_node(n.message))
+		obj.add_terse('file_path', t.string_node(n.file_path))
 		obj.add('pos', t.pos(n.pos))
 		obj.add('reporter', t.enum_node(n.reporter))
 		notice_array.add_item(obj)
@@ -582,7 +581,11 @@ fn (t Tree) anon_fn(node ast.AnonFn) &Node {
 	obj.add_terse('decl', t.fn_decl(node.decl))
 	obj.add('inherited_vars', t.array_node_arg(node.inherited_vars))
 	obj.add_terse('typ', t.type_node(node.typ))
-	obj.add('has_gen', t.bool_node(node.has_gen))
+	symbol_obj := new_object()
+	for key, val in node.has_gen {
+		symbol_obj.add_terse(key.str(), t.bool_node(val))
+	}
+	obj.add_terse('has_gen', symbol_obj)
 	return obj
 }
 
@@ -612,7 +615,10 @@ fn (t Tree) struct_field(node ast.StructField) &Node {
 	obj.add_terse('ast_type', t.string_node('StructField'))
 	obj.add_terse('name', t.string_node(node.name))
 	obj.add_terse('typ', t.type_node(node.typ))
+	obj.add_terse('anon_struct_decl', t.struct_decl(node.anon_struct_decl))
+	obj.add_terse('unaliased_typ', t.type_node(node.unaliased_typ))
 	obj.add('type_pos', t.pos(node.type_pos))
+	obj.add('option_pos', t.pos(node.option_pos))
 	obj.add_terse('has_default_expr', t.bool_node(node.has_default_expr))
 	obj.add_terse('default_expr_typ', t.type_node(node.default_expr_typ))
 	obj.add_terse('default_expr', t.expr(node.default_expr))
@@ -620,9 +626,11 @@ fn (t Tree) struct_field(node ast.StructField) &Node {
 	obj.add_terse('is_mut', t.bool_node(node.is_mut))
 	obj.add_terse('is_global', t.bool_node(node.is_global))
 	obj.add_terse('is_volatile', t.bool_node(node.is_volatile))
+	obj.add_terse('is_deprecated', t.bool_node(node.is_deprecated))
 	obj.add_terse('attrs', t.array_node_attr(node.attrs))
 	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add('pos', t.pos(node.pos))
+	obj.add_terse('i', t.number_node(node.i))
 	return obj
 }
 
@@ -645,6 +653,7 @@ fn (t Tree) enum_decl(node ast.EnumDecl) &Node {
 	obj.add_terse('fields', t.array_node_enum_field(node.fields))
 	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add_terse('attrs', t.array_node_attr(node.attrs))
+	obj.add_terse('typ', t.type_node(node.typ))
 	return obj
 }
 
@@ -674,8 +683,8 @@ fn (t Tree) interface_decl(node ast.InterfaceDecl) &Node {
 	obj.add('name_pos', t.pos(node.name_pos))
 	obj.add_terse('language', t.enum_node(node.language))
 	obj.add('pos', t.pos(node.pos))
-	obj.add('are_ifaces_expanded', t.bool_node(node.are_ifaces_expanded))
-	obj.add_terse('ifaces', t.array_node_interface_embedding(node.ifaces))
+	obj.add('are_embeds_expanded', t.bool_node(node.are_embeds_expanded))
+	obj.add_terse('embeds', t.array_node_interface_embedding(node.embeds))
 	obj.add_terse('attrs', t.array_node_attr(node.attrs))
 	return obj
 }
@@ -779,8 +788,9 @@ fn (t Tree) alias_type_decl(node ast.AliasTypeDecl) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('AliasTypeDecl'))
 	obj.add_terse('name', t.string_node(node.name))
-	obj.add_terse('is_pub', t.bool_node(node.is_pub))
+	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('parent_type', t.type_node(node.parent_type))
+	obj.add_terse('is_pub', t.bool_node(node.is_pub))
 	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add('pos', t.pos(node.pos))
 	return obj
@@ -794,8 +804,8 @@ fn (t Tree) sum_type_decl(node ast.SumTypeDecl) &Node {
 	obj.add('pos', t.pos(node.pos))
 	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('generic_types', t.array_node_type(node.generic_types))
-	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add_terse('variants', t.array_node_type_expr(node.variants))
+	obj.add('name_pos', t.pos(node.name_pos))
 	return obj
 }
 
@@ -823,6 +833,7 @@ fn (t Tree) goto_label(node ast.GotoLabel) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('GotoLabel'))
 	obj.add_terse('name', t.string_node(node.name))
+	obj.add_terse('is_used', t.bool_node(node.is_used))
 	obj.add('pos', t.pos(node.pos))
 	return obj
 }
@@ -864,11 +875,13 @@ fn (t Tree) var(node ast.Var) &Node {
 	obj.add_terse('is_mut', t.bool_node(node.is_mut))
 	obj.add('is_used', t.bool_node(node.is_used))
 	obj.add('is_changed', t.bool_node(node.is_changed))
+	obj.add_terse('ct_type_var', t.enum_node(node.ct_type_var))
 	obj.add('is_or', t.bool_node(node.is_or))
 	obj.add('is_tmp', t.bool_node(node.is_tmp))
 	obj.add('is_autofree_tmp', t.bool_node(node.is_autofree_tmp))
 	obj.add('is_auto_deref', t.bool_node(node.is_auto_deref))
 	obj.add('is_inherited', t.bool_node(node.is_inherited))
+	obj.add('has_inherited', t.bool_node(node.has_inherited))
 	obj.add('is_auto_heap', t.bool_node(node.is_auto_heap))
 	obj.add('is_stack_obj', t.bool_node(node.is_stack_obj))
 	obj.add_terse('share', t.enum_node(node.share))
@@ -898,6 +911,7 @@ fn (t Tree) for_c_stmt(node ast.ForCStmt) &Node {
 	obj.add_terse('is_multi', t.bool_node(node.is_multi))
 	obj.add_terse('label', t.string_node(node.label))
 	obj.add('pos', t.pos(node.pos))
+	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add('scope', t.number_node(int(node.scope)))
 	obj.add_terse('stmts', t.array_node_stmt(node.stmts))
 	return obj
@@ -910,6 +924,7 @@ fn (t Tree) for_stmt(node ast.ForStmt) &Node {
 	obj.add_terse('is_inf', t.bool_node(node.is_inf))
 	obj.add_terse('label', t.string_node(node.label))
 	obj.add('pos', t.pos(node.pos))
+	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add('scope', t.number_node(int(node.scope)))
 	obj.add_terse('stmts', t.array_node_stmt(node.stmts))
 	return obj
@@ -928,8 +943,10 @@ fn (t Tree) for_in_stmt(node ast.ForInStmt) &Node {
 	obj.add_terse('cond_type', t.type_node(node.cond_type))
 	obj.add_terse('kind', t.enum_node(node.kind))
 	obj.add_terse('val_is_mut', t.bool_node(node.val_is_mut))
+	obj.add_terse('val_is_ref', t.bool_node(node.val_is_ref))
 	obj.add_terse('label', t.string_node(node.label))
 	obj.add('pos', t.pos(node.pos))
+	obj.add('comments', t.array_node_comment(node.comments))
 	obj.add('scope', t.number_node(int(node.scope)))
 	obj.add_terse('stmts', t.array_node_stmt(node.stmts))
 	return obj
@@ -949,6 +966,10 @@ fn (t Tree) assert_stmt(node ast.AssertStmt) &Node {
 	obj.add_terse('ast_type', t.string_node('AssertStmt'))
 	obj.add_terse('expr', t.expr(node.expr))
 	obj.add_terse('is_used', t.bool_node(node.is_used))
+	if node.extra !is ast.EmptyExpr {
+		obj.add_terse('extra', t.expr(node.extra))
+		obj.add('extra_pos', t.pos(node.extra_pos))
+	}
 	obj.add('pos', t.pos(node.pos))
 	return obj
 }
@@ -980,6 +1001,7 @@ fn (t Tree) comptime_call(node ast.ComptimeCall) &Node {
 	obj.add_terse('env_value', t.string_node(node.env_value))
 	obj.add('pos', t.pos(node.pos))
 	obj.add_terse('args', t.array_node_call_arg(node.args))
+	obj.add_terse('or_block', t.or_expr(node.or_block))
 	return obj
 }
 
@@ -1144,6 +1166,9 @@ fn (t Tree) expr(expr ast.Expr) &Node {
 		ast.GoExpr {
 			return t.go_expr(expr)
 		}
+		ast.SpawnExpr {
+			return t.spawn_expr(expr)
+		}
 		ast.OffsetOf {
 			return t.offset_of(expr)
 		}
@@ -1156,6 +1181,9 @@ fn (t Tree) expr(expr ast.Expr) &Node {
 		ast.EmptyExpr {
 			return t.empty_expr(expr)
 		}
+		ast.Nil {
+			return t.nil_expr(expr)
+		}
 		else {
 			// println('unknown expr')
 			return t.null_node()
@@ -1216,7 +1244,7 @@ fn (t Tree) string_inter_literal(node ast.StringInterLiteral) &Node {
 	obj.add_terse('pluss', t.array_node_bool(node.pluss))
 	obj.add_terse('fills', t.array_node_bool(node.fills))
 	obj.add_terse('fmt_poss', t.array_node_position(node.fmt_poss))
-	obj.add_terse('fmts', t.array_node_byte(node.fmts))
+	obj.add_terse('fmts', t.array_node_u8(node.fmts))
 	obj.add_terse('need_fmts', t.array_node_bool(node.need_fmts))
 	obj.add('pos', t.pos(node.pos))
 	return obj
@@ -1290,6 +1318,7 @@ fn (t Tree) type_expr(node ast.TypeNode) &Node {
 fn (t Tree) size_of(node ast.SizeOf) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('SizeOf'))
+	obj.add_terse('guessed_type', t.bool_node(node.guessed_type))
 	obj.add_terse('is_type', t.bool_node(node.is_type))
 	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('expr', t.expr(node.expr))
@@ -1300,6 +1329,7 @@ fn (t Tree) size_of(node ast.SizeOf) &Node {
 fn (t Tree) is_ref_type(node ast.IsRefType) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('IsRefType'))
+	obj.add_terse('guessed_type', t.bool_node(node.guessed_type))
 	obj.add_terse('is_type', t.bool_node(node.is_type))
 	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('expr', t.expr(node.expr))
@@ -1327,6 +1357,7 @@ fn (t Tree) infix_expr(node ast.InfixExpr) &Node {
 	obj.add_terse('left_type', t.type_node(node.left_type))
 	obj.add_terse('right', t.expr(node.right))
 	obj.add_terse('right_type', t.type_node(node.right_type))
+	obj.add_terse('promoted_type', t.type_node(node.promoted_type))
 	obj.add('auto_locked', t.string_node(node.auto_locked))
 	obj.add_terse('or_block', t.or_expr(node.or_block))
 	obj.add_terse('is_stmt', t.bool_node(node.is_stmt))
@@ -1358,6 +1389,7 @@ fn (t Tree) postfix_expr(node ast.PostfixExpr) &Node {
 	obj.add_terse('expr', t.expr(node.expr))
 	obj.add('auto_locked', t.string_node(node.auto_locked))
 	obj.add('pos', t.pos(node.pos))
+	obj.add('is_c2v_prefix', t.bool_node(node.is_c2v_prefix))
 	return obj
 }
 
@@ -1369,8 +1401,10 @@ fn (t Tree) selector_expr(node ast.SelectorExpr) &Node {
 	obj.add_terse('field_name', t.string_node(node.field_name))
 	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('name_type', t.type_node(node.name_type))
+	obj.add_terse('or_block', t.or_expr(node.or_block))
 	obj.add_terse('gkind_field', t.enum_node(node.gkind_field))
 	obj.add_terse('from_embed_types', t.array_node_type(node.from_embed_types))
+	obj.add_terse('has_hidden_receiver', t.bool_node(node.has_hidden_receiver))
 	obj.add_terse('next_token', t.token_node(node.next_token))
 	obj.add('pos', t.pos(node.pos))
 	obj.add('scope', t.number_node(int(node.scope)))
@@ -1384,6 +1418,7 @@ fn (t Tree) range_expr(node ast.RangeExpr) &Node {
 	obj.add_terse('high', t.expr(node.high))
 	obj.add_terse('has_high', t.bool_node(node.has_high))
 	obj.add_terse('has_low', t.bool_node(node.has_low))
+	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add('pos', t.pos(node.pos))
 	return obj
 }
@@ -1431,6 +1466,7 @@ fn (t Tree) ident(node ast.Ident) &Node {
 	obj.add('mut_pos', t.pos(node.mut_pos))
 	obj.add('obj', t.scope_object(node.obj))
 	obj.add('scope', t.number_node(int(node.scope)))
+	obj.add_terse('or_expr', t.or_expr(node.or_expr))
 	return obj
 }
 
@@ -1448,7 +1484,7 @@ fn (t Tree) ident_var(node ast.IdentVar) &Node {
 	obj.add_terse('is_mut', t.bool_node(node.is_mut))
 	obj.add_terse('is_static', t.bool_node(node.is_static))
 	obj.add_terse('is_volatile', t.bool_node(node.is_volatile))
-	obj.add_terse('is_optional', t.bool_node(node.is_optional))
+	obj.add_terse('is_option', t.bool_node(node.is_option))
 	obj.add_terse('share', t.enum_node(node.share))
 	return obj
 }
@@ -1465,12 +1501,17 @@ fn (t Tree) call_expr(node ast.CallExpr) &Node {
 	obj.add_terse('ast_type', t.string_node('CallExpr'))
 	obj.add_terse('mod', t.string_node(node.mod))
 	obj.add_terse('name', t.string_node(node.name))
+	obj.add_terse('const_name', t.string_node(node.const_name))
 	obj.add_terse('language', t.enum_node(node.language))
 	obj.add_terse('left_type', t.type_node(node.left_type))
 	obj.add_terse('receiver_type', t.type_node(node.receiver_type))
 	obj.add_terse('return_type', t.type_node(node.return_type))
+	obj.add_terse('fn_var_type', t.type_node(node.fn_var_type))
 	obj.add_terse('left', t.expr(node.left))
 	obj.add_terse('is_method', t.bool_node(node.is_method))
+	obj.add_terse('is_field', t.bool_node(node.is_field))
+	obj.add_terse('is_fn_var', t.bool_node(node.is_fn_var))
+	obj.add_terse('is_fn_a_const', t.bool_node(node.is_fn_a_const))
 	obj.add('is_keep_alive', t.bool_node(node.is_keep_alive))
 	obj.add_terse('is_noreturn', t.bool_node(node.is_noreturn))
 	obj.add_terse('is_ctor_new', t.bool_node(node.is_ctor_new))
@@ -1515,7 +1556,9 @@ fn (t Tree) struct_init(node ast.StructInit) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('StructInit'))
 	obj.add_terse('typ', t.type_node(node.typ))
-	obj.add_terse('is_short', t.bool_node(node.is_short))
+	obj.add_terse('no_keys', t.bool_node(node.no_keys))
+	obj.add_terse('is_short_syntax', t.bool_node(node.is_short_syntax))
+	obj.add_terse('is_anon', t.bool_node(node.is_anon))
 	obj.add_terse('unresolved', t.bool_node(node.unresolved))
 	obj.add_terse('has_update_expr', t.bool_node(node.has_update_expr))
 	obj.add_terse('update_expr', t.expr(node.update_expr))
@@ -1575,7 +1618,7 @@ fn (t Tree) array_init(node ast.ArrayInit) &Node {
 	obj.add_terse('has_len', t.bool_node(node.has_len))
 	obj.add_terse('has_cap', t.bool_node(node.has_cap))
 	obj.add_terse('has_default', t.bool_node(node.has_default))
-	obj.add_terse('has_it', t.bool_node(node.has_it))
+	obj.add_terse('has_index', t.bool_node(node.has_index))
 	obj.add_terse('expr_types', t.array_node_type(node.expr_types))
 	obj.add('pos', t.pos(node.pos))
 	return obj
@@ -1671,8 +1714,9 @@ fn (t Tree) concat_expr(node ast.ConcatExpr) &Node {
 fn (t Tree) type_of(node ast.TypeOf) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('TypeOf'))
+	obj.add_terse('is_type', t.bool_node(node.is_type))
+	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('expr', t.expr(node.expr))
-	obj.add_terse('expr_type', t.type_node(node.expr_type))
 	obj.add('pos', t.pos(node.pos))
 	return obj
 }
@@ -1699,7 +1743,9 @@ fn (t Tree) sql_expr(node ast.SqlExpr) &Node {
 	obj.add_terse('order_expr', t.expr(node.order_expr))
 	obj.add_terse('has_desc', t.bool_node(node.has_desc))
 	obj.add_terse('is_array', t.bool_node(node.is_array))
+	obj.add_terse('or_expr', t.or_expr(node.or_expr))
 	obj.add('pos', t.pos(node.pos))
+	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add_terse('has_limit', t.bool_node(node.has_limit))
 	obj.add_terse('limit_expr', t.expr(node.limit_expr))
 	obj.add_terse('has_offset', t.bool_node(node.has_offset))
@@ -1716,7 +1762,9 @@ fn (t Tree) sql_expr(node ast.SqlExpr) &Node {
 fn (t Tree) sql_stmt(node ast.SqlStmt) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('SqlStmt'))
+	obj.add_terse('db_expr_type', t.type_node(node.db_expr_type))
 	obj.add_terse('db_expr', t.expr(node.db_expr))
+	obj.add_terse('or_expr', t.or_expr(node.or_expr))
 	obj.add('pos', t.pos(node.pos))
 	obj.add_terse('lines', t.array_node_sql_stmt_line(node.lines))
 	return obj
@@ -1770,6 +1818,7 @@ fn (t Tree) chan_init(expr ast.ChanInit) &Node {
 	obj.add_terse('typ', t.type_node(expr.typ))
 	obj.add_terse('elem_type', t.type_node(expr.elem_type))
 	obj.add('pos', t.pos(expr.pos))
+	obj.add('elem_type_pos', t.pos(expr.elem_type_pos))
 	return obj
 }
 
@@ -1816,6 +1865,15 @@ fn (t Tree) go_expr(expr ast.GoExpr) &Node {
 	return obj
 }
 
+fn (t Tree) spawn_expr(expr ast.SpawnExpr) &Node {
+	mut obj := new_object()
+	obj.add_terse('ast_type', t.string_node('SpawnExpr'))
+	obj.add_terse('call_expr', t.call_expr(expr.call_expr))
+	obj.add_terse('is_expr', t.bool_node(expr.is_expr))
+	obj.add('pos', t.pos(expr.pos))
+	return obj
+}
+
 fn (t Tree) offset_of(expr ast.OffsetOf) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('OffsetOf'))
@@ -1856,6 +1914,13 @@ fn (t Tree) empty_stmt(node ast.EmptyStmt) &Node {
 	return obj
 }
 
+fn (t Tree) nil_expr(node ast.Nil) &Node {
+	mut obj := new_object()
+	obj.add_terse('ast_type', t.string_node('Nil'))
+	obj.add('pos', t.pos(node.pos))
+	return obj
+}
+
 fn (t Tree) asm_stmt(node ast.AsmStmt) &Node {
 	mut obj := new_object()
 	obj.add_terse('ast_type', t.string_node('AsmStmt'))
@@ -1978,7 +2043,7 @@ fn (t Tree) asm_io(node ast.AsmIO) &Node {
 }
 
 // do not support yet by vlang
-// fn (t Tree) array_node1<T>(nodes []T, method_name string) &Node {
+// fn (t Tree) array_node1[T](nodes []T, method_name string) &Node {
 // 	mut arr := new_array()
 
 // 	// call method dynamically, V do not support yet
@@ -2001,7 +2066,7 @@ fn (t Tree) asm_io(node ast.AsmIO) &Node {
 // }
 
 // do not support yet by vlang
-// fn (t Tree) array_node2<T>(nodes []T) &Node {
+// fn (t Tree) array_node2[T](nodes []T) &Node {
 // 	mut arr := new_array()
 
 // 	for node in nodes {
@@ -2209,7 +2274,7 @@ fn (t Tree) array_node_int(nodes []int) &Node {
 	return arr
 }
 
-fn (t Tree) array_node_byte(nodes []byte) &Node {
+fn (t Tree) array_node_u8(nodes []u8) &Node {
 	mut arr := new_array()
 	for node in nodes {
 		arr.add_item(t.number_node(node))

cmd/tools/vbin2v.v

@@ -20,22 +20,22 @@ mut:
 
 fn (context Context) header() string {
 	mut header_s := ''
-	header_s += 'module $context.module_name\n'
+	header_s += 'module ${context.module_name}\n'
 	header_s += '\n'
 	allfiles := context.files.join(' ')
 	mut options := []string{}
 	if context.prefix.len > 0 {
-		options << '-p $context.prefix'
+		options << '-p ${context.prefix}'
 	}
 	if context.module_name.len > 0 {
-		options << '-m $context.module_name'
+		options << '-m ${context.module_name}'
 	}
 	if context.write_file.len > 0 {
-		options << '-w $context.write_file'
+		options << '-w ${context.write_file}'
 	}
 	soptions := options.join(' ')
 	header_s += '// File generated by:\n'
-	header_s += '// v bin2v $allfiles $soptions\n'
+	header_s += '// v bin2v ${allfiles} ${soptions}\n'
 	header_s += '// Please, do not edit this file.\n'
 	header_s += '// Your changes may be overwritten.\n'
 	header_s += 'const (\n'
@@ -46,12 +46,12 @@ fn (context Context) footer() string {
 	return ')\n'
 }
 
-fn (context Context) file2v(bname string, fbytes []byte, bn_max int) string {
+fn (context Context) file2v(bname string, fbytes []u8, bn_max int) string {
 	mut sb := strings.new_builder(1000)
 	bn_diff_len := bn_max - bname.len
-	sb.write_string('\t${bname}_len' + ' '.repeat(bn_diff_len - 4) + ' = $fbytes.len\n')
+	sb.write_string('\t${bname}_len' + ' '.repeat(bn_diff_len - 4) + ' = ${fbytes.len}\n')
 	fbyte := fbytes[0]
-	bnmae_line := '\t$bname' + ' '.repeat(bn_diff_len) + ' = [byte($fbyte), '
+	bnmae_line := '\t${bname}' + ' '.repeat(bn_diff_len) + ' = [u8(${fbyte}), '
 	sb.write_string(bnmae_line)
 	mut line_len := bnmae_line.len + 3
 	for i := 1; i < fbytes.len; i++ {
@@ -65,7 +65,7 @@ fn (context Context) file2v(bname string, fbytes []byte, bn_max int) string {
 			sb.write_string(b)
 			line_len += b.len
 		} else {
-			sb.write_string('$b, ')
+			sb.write_string('${b}, ')
 			line_len += b.len + 2
 		}
 	}
@@ -73,11 +73,11 @@ fn (context Context) file2v(bname string, fbytes []byte, bn_max int) string {
 	return sb.str()
 }
 
-fn (context Context) bname_and_bytes(file string) ?(string, []byte) {
+fn (context Context) bname_and_bytes(file string) !(string, []u8) {
 	fname := os.file_name(file)
 	fname_escaped := fname.replace_each(['.', '_', '-', '_'])
-	byte_name := '$context.prefix$fname_escaped'.to_lower()
-	fbytes := os.read_bytes(file) or { return error('Error: $err.msg') }
+	byte_name := '${context.prefix}${fname_escaped}'.to_lower()
+	fbytes := os.read_bytes(file) or { return error('Error: ${err.msg()}') }
 	return byte_name, fbytes
 }
 
@@ -108,7 +108,7 @@ fn main() {
 		exit(0)
 	}
 	files := fp.finalize() or {
-		eprintln('Error: $err.msg')
+		eprintln('Error: ${err.msg()}')
 		exit(1)
 	}
 	real_files := files.filter(it != 'bin2v')
@@ -120,22 +120,22 @@ fn main() {
 	if context.write_file != '' && os.file_ext(context.write_file) !in ['.vv', '.v'] {
 		context.write_file += '.v'
 	}
-	mut file_byte_map := map[string][]byte{}
+	mut file_byte_map := map[string][]u8{}
 	for file in real_files {
 		bname, fbytes := context.bname_and_bytes(file) or {
-			eprintln(err.msg)
+			eprintln(err.msg())
 			exit(1)
 		}
 		file_byte_map[bname] = fbytes
 	}
 	max_bname := context.max_bname_len(file_byte_map.keys())
 	if context.write_file.len > 0 {
-		mut out_file := os.create(context.write_file) ?
-		out_file.write_string(context.header()) ?
+		mut out_file := os.create(context.write_file)!
+		out_file.write_string(context.header())!
 		for bname, fbytes in file_byte_map {
-			out_file.write_string(context.file2v(bname, fbytes, max_bname)) ?
+			out_file.write_string(context.file2v(bname, fbytes, max_bname))!
 		}
-		out_file.write_string(context.footer()) ?
+		out_file.write_string(context.footer())!
 	} else {
 		print(context.header())
 		for bname, fbytes in file_byte_map {

cmd/tools/vbug.v

@@ -8,9 +8,9 @@ const vroot = @VMODROOT
 fn get_vdoctor_output(is_verbose bool) string {
 	vexe := os.getenv('VEXE')
 	verbose_flag := if is_verbose { '-v' } else { '' }
-	result := os.execute('${os.quoted_path(vexe)} $verbose_flag doctor')
+	result := os.execute('${os.quoted_path(vexe)} ${verbose_flag} doctor')
 	if result.exit_code != 0 {
-		eprintln('unable to get `v doctor` output: $result.output')
+		eprintln('unable to get `v doctor` output: ${result.output}')
 		return ''
 	}
 	return result.output
@@ -23,21 +23,21 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 	wd := os.getwd()
 	os.chdir(vroot) or {}
 	verbose_flag := if is_verbose { '-v' } else { '' }
-	vdbg_path := $if windows { '$vroot/vdbg.exe' } $else { '$vroot/vdbg' }
-	vdbg_compilation_cmd := '${os.quoted_path(vexe)} $verbose_flag -g -o ${os.quoted_path(vdbg_path)} cmd/v'
+	vdbg_path := $if windows { '${vroot}/vdbg.exe' } $else { '${vroot}/vdbg' }
+	vdbg_compilation_cmd := '${os.quoted_path(vexe)} ${verbose_flag} -g -o ${os.quoted_path(vdbg_path)} cmd/v'
 	vdbg_result := os.execute(vdbg_compilation_cmd)
 	os.chdir(wd) or {}
 	if vdbg_result.exit_code == 0 {
 		vexe = vdbg_path
 	} else {
-		eprintln('unable to compile V in debug mode: $vdbg_result.output\ncommand: $vdbg_compilation_cmd\n')
+		eprintln('unable to compile V in debug mode: ${vdbg_result.output}\ncommand: ${vdbg_compilation_cmd}\n')
 	}
 	//
-	mut result := os.execute('${os.quoted_path(vexe)} $verbose_flag ${os.quoted_path(file_path)}')
+	mut result := os.execute('${os.quoted_path(vexe)} ${verbose_flag} ${os.quoted_path(file_path)}')
 	defer {
 		os.rm(vdbg_path) or {
 			if is_verbose {
-				eprintln('unable to delete `vdbg`: $err')
+				eprintln('unable to delete `vdbg`: ${err}')
 			}
 		}
 	}
@@ -49,14 +49,14 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 			}
 			os.rm(generated_file) or {
 				if is_verbose {
-					eprintln('unable to delete generated file: $err')
+					eprintln('unable to delete generated file: ${err}')
 				}
 			}
 		}
 		run := is_yes
 			|| ask('It looks like the compilation went well, do you want to run the file?')
 		if run {
-			result = os.execute('${os.quoted_path(vexe)} $verbose_flag run ${os.quoted_path(file_path)}')
+			result = os.execute('${os.quoted_path(vexe)} ${verbose_flag} run ${os.quoted_path(file_path)}')
 			if result.exit_code == 0 && !is_yes {
 				confirm_or_exit('It looks like the file ran correctly as well, are you sure you want to continue?')
 			}
@@ -66,7 +66,7 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 }
 
 fn ask(msg string) bool {
-	prompt := os.input_opt('$msg [Y/n] ') or { 'y' }
+	prompt := os.input_opt('${msg} [Y/n] ') or { 'y' }
 	return prompt == '' || prompt[0].ascii_str().to_lower() != 'n'
 }
 
@@ -90,7 +90,7 @@ fn main() {
 			}
 			else {
 				if !arg.ends_with('.v') && !arg.ends_with('.vsh') && !arg.ends_with('.vv') {
-					eprintln('unknown argument: `$arg`')
+					eprintln('unknown argument: `${arg}`')
 					exit(1)
 				}
 				if file_path != '' {
@@ -111,14 +111,14 @@ fn main() {
 	vdoctor_output := get_vdoctor_output(is_verbose)
 	// file content
 	file_content := os.read_file(file_path) or {
-		eprintln('unable to get file "$file_path" content: $err')
+		eprintln('unable to get file "${file_path}" content: ${err}')
 		''
 	}
 	// output from `v -g -o vdbg cmd/v && vdbg file.v`
 	build_output := get_v_build_output(is_verbose, is_yes, file_path)
 	// ask the user if he wants to submit even after an error
 	if !is_yes && (vdoctor_output == '' || file_content == '' || build_output == '') {
-		confirm_or_exit('An error occured retrieving the information, do you want to continue?')
+		confirm_or_exit('An error occurred retrieving the information, do you want to continue?')
 	}
 
 	expected_result := readline.read_line('What did you expect to see? ') or {
@@ -136,26 +136,26 @@ fn main() {
 	raw_body := '<!-- It is advisable to update all relevant modules using `v outdated` and `v install` -->
 **V doctor:**
 ```
-$vdoctor_output
+${vdoctor_output}
 ```
 
 **What did you do?**
-`v -g -o vdbg cmd/v && vdbg $file_path`
+`v -g -o vdbg cmd/v && vdbg ${file_path}`
 {file_content}
 
 **What did you expect to see?**
 
-$expected_result
+${expected_result}
 
 **What did you see instead?**
 ```
-$build_output```'
-	mut encoded_body := urllib.query_escape(raw_body.replace_once('{file_content}', '```v\n$file_content\n```'))
-	mut generated_uri := 'https://github.com/vlang/v/issues/new?labels=Bug&body=$encoded_body'
+${build_output}```'
+	mut encoded_body := urllib.query_escape(raw_body.replace_once('{file_content}', '```v\n${file_content}\n```'))
+	mut generated_uri := 'https://github.com/vlang/v/issues/new?labels=Bug&body=${encoded_body}'
 	if generated_uri.len > 8192 {
 		// GitHub doesn't support URLs longer than 8192 characters
-		encoded_body = urllib.query_escape(raw_body.replace_once('{file_content}', 'See attached file `$file_path`'))
-		generated_uri = 'https://github.com/vlang/v/issues/new?labels=Bug&body=$encoded_body'
+		encoded_body = urllib.query_escape(raw_body.replace_once('{file_content}', 'See attached file `${file_path}`'))
+		generated_uri = 'https://github.com/vlang/v/issues/new?labels=Bug&body=${encoded_body}'
 		println('Your file is too big to be submitted. Head over to the following URL and attach your file.')
 		println(generated_uri)
 	} else {

cmd/tools/vbuild-examples.v

@@ -3,16 +3,23 @@ module main
 import os
 import testing
 
-const vroot = @VMODROOT
+const vroot = os.dir(os.real_path(os.getenv_opt('VEXE') or { @VEXE }))
 
+// build as a project folder
 const efolders = [
 	'examples/viewer',
+	'examples/vweb_orm_jwt',
+	'examples/vweb_fullstack',
 ]
 
+pub fn normalised_vroot_path(path string) string {
+	return os.real_path(os.join_path_single(vroot, path)).replace('\\', '/')
+}
+
 fn main() {
 	args_string := os.args[1..].join(' ')
 	params := args_string.all_before('build-examples')
-	skip_prefixes := efolders.map(os.real_path(os.join_path_single(vroot, it)))
+	mut skip_prefixes := efolders.map(normalised_vroot_path(it))
 	res := testing.v_build_failing_skipped(params, 'examples', skip_prefixes, fn (mut session testing.TestSession) {
 		for x in efolders {
 			pathsegments := x.split_any('/')

cmd/tools/vbuild-tools.v

@@ -4,14 +4,14 @@ import os
 import testing
 import v.util
 
-// NB: tools like vdoc are compiled in their own subfolder
+// Note: tools like vdoc are compiled in their own subfolder
 // => cmd/tools/vdoc/vdoc.exe
 // Usually, they have several top level .v files in the subfolder,
 // that cannot be compiled separately, but instead, the whole folder,
 // should be compiled (v folder).
 // To implement that, these folders are initially skipped, then added
 // as a whole *after the testing.prepare_test_session call*.
-const tools_in_subfolders = ['vdoc', 'vvet', 'vast']
+const tools_in_subfolders = ['vdoc', 'vvet', 'vast', 'vwhere', 'vcreate']
 
 // non_packaged_tools are tools that should not be packaged with
 // prebuild versions of V, to keep the size smaller.
@@ -23,15 +23,15 @@ fn main() {
 	args_string := os.args[1..].join(' ')
 	vexe := os.getenv('VEXE')
 	vroot := os.dir(vexe)
-	os.chdir(vroot) ?
+	os.chdir(vroot)!
 	folder := os.join_path('cmd', 'tools')
 	tfolder := os.join_path(vroot, 'cmd', 'tools')
-	main_label := 'Building $folder ...'
-	finish_label := 'building $folder'
+	main_label := 'Building ${folder} ...'
+	finish_label := 'building ${folder}'
 	//
 	mut skips := []string{}
 	for stool in tools_in_subfolders {
-		skips << os.join_path(tfolder, stool)
+		skips << os.join_path(tfolder, stool).replace('\\', '/')
 	}
 	buildopts := args_string.all_before('build-tools')
 	mut session := testing.prepare_test_session(buildopts, folder, skips, main_label)
@@ -43,11 +43,11 @@ fn main() {
 	// eprintln('> session.skip_files: $session.skip_files')
 	session.test()
 	eprintln(session.benchmark.total_message(finish_label))
-	if session.failed {
+	if session.failed_cmds.len > 0 {
 		exit(1)
 	}
 	//
-	mut executables := os.ls(session.vtmp_dir) ?
+	mut executables := os.ls(session.vtmp_dir)!
 	executables.sort()
 	for texe in executables {
 		tname := texe.replace(os.file_ext(texe), '')
@@ -66,8 +66,9 @@ fn main() {
 		}
 		target_path := os.join_path(tfolder, texe)
 		os.mv_by_cp(tpath, target_path) or {
-			if !err.msg.contains('vbuild-tools') && !err.msg.contains('vtest-all') {
-				eprintln('error while moving $tpath to $target_path: $err.msg')
+			emsg := err.msg()
+			if !emsg.contains('vbuild-tools') && !emsg.contains('vtest-all') {
+				eprintln('error while moving ${tpath} to ${target_path}: ${emsg}')
 			}
 			continue
 		}

cmd/tools/vbump.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 Subhomoy Haldar. All rights reserved.
+// Copyright (c) 2019-2023 Subhomoy Haldar. All rights reserved.
 // Use of this source code is governed by an MIT license that can be found in the LICENSE file.
 module main
 
@@ -20,7 +20,7 @@ const (
     tool_version = \'1.2.1\'
     version: \'0.2.42\'
     VERSION = "1.23.8"
-  
+
 Examples:
   Bump the patch version in v.mod if it exists
     v bump --patch
@@ -68,7 +68,7 @@ fn get_replacement_function(options Options) ReplacementFunction {
 }
 
 fn process_file(input_file string, options Options) {
-	lines := os.read_lines(input_file) or { panic('Failed to read file: $input_file') }
+	lines := os.read_lines(input_file) or { panic('Failed to read file: ${input_file}') }
 
 	mut re := regex.regex_opt(semver_query) or { panic('Could not create a RegEx parser.') }
 
@@ -103,28 +103,28 @@ fn process_file(input_file string, options Options) {
 	os.rm(backup_file) or {}
 
 	// Rename the original to the backup.
-	os.mv(input_file, backup_file) or { panic('Failed to copy file: $input_file') }
+	os.mv(input_file, backup_file) or { panic('Failed to copy file: ${input_file}') }
 
 	// Process the old file and write it back to the original.
 	os.write_file(input_file, new_lines.join_lines()) or {
-		panic('Failed to write file: $input_file')
+		panic('Failed to write file: ${input_file}')
 	}
 
 	// Remove the backup file.
 	os.rm(backup_file) or {}
 
 	if replacement_complete {
-		println('Bumped version in $input_file')
+		println('Bumped version in ${input_file}')
 	} else {
-		println('No changes made in $input_file')
+		println('No changes made in ${input_file}')
 	}
 }
 
 fn main() {
 	if os.args.len < 2 {
-		println('Usage: $tool_name [options] [file1 file2 ...]
-$tool_description
-Try $tool_name -h for more help...')
+		println('Usage: ${tool_name} [options] [file1 file2 ...]
+${tool_description}
+Try ${tool_name} -h for more help...')
 		exit(1)
 	}
 
@@ -162,14 +162,14 @@ Try $tool_name -h for more help...')
 
 	for input_file in files {
 		if !os.exists(input_file) {
-			println('File not found: $input_file')
+			println('File not found: ${input_file}')
 			exit(1)
 		}
 		process_file(input_file, options)
 	}
 }
 
-fn validate_options(options Options) ? {
+fn validate_options(options Options) ! {
 	if options.patch && options.major {
 		return error('Cannot specify both --patch and --major.')
 	}

cmd/tools/vbump_test.v

@@ -1,5 +1,17 @@
 import os
 
+const vexe = @VEXE
+
+const tfolder = os.join_path(os.vtmp_dir(), 'v', 'vbump')
+
+fn testsuite_begin() {
+	os.mkdir_all(tfolder) or {}
+}
+
+fn testsuite_end() {
+	os.rmdir_all(tfolder) or {}
+}
+
 struct BumpTestCase {
 	file_name      string
 	contents       string
@@ -61,28 +73,25 @@ fn main() {
 	},
 ]
 
-fn run_individual_test(case BumpTestCase) ? {
-	vexe := @VEXE
-
-	temp_dir := os.temp_dir()
-	test_file := os.join_path_single(temp_dir, case.file_name)
+fn run_individual_test(case BumpTestCase) ! {
+	test_file := os.join_path_single(tfolder, case.file_name)
 
 	os.rm(test_file) or {}
-	os.write_file(test_file, case.contents) ?
+	os.write_file(test_file, case.contents)!
 	//
 	os.execute_or_exit('${os.quoted_path(vexe)} bump --patch ${os.quoted_path(test_file)}')
-	patch_lines := os.read_lines(test_file) ?
+	patch_lines := os.read_lines(test_file)!
 	assert patch_lines[case.line] == case.expected_patch
 
 	os.execute_or_exit('${os.quoted_path(vexe)} bump --minor ${os.quoted_path(test_file)}')
-	minor_lines := os.read_lines(test_file) ?
+	minor_lines := os.read_lines(test_file)!
 	assert minor_lines[case.line] == case.expected_minor
 
 	os.execute_or_exit('${os.quoted_path(vexe)} bump --major ${os.quoted_path(test_file)}')
-	major_lines := os.read_lines(test_file) ?
+	major_lines := os.read_lines(test_file)!
 	assert major_lines[case.line] == case.expected_major
 	//
-	os.rm(test_file) ?
+	os.rm(test_file)!
 }
 
 fn test_all_bump_cases() {

cmd/tools/vcheck-md.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2023 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
 module main
@@ -7,8 +7,7 @@ import os
 import os.cmdline
 import rand
 import term
-import vhelp
-import v.pref
+import v.help
 import regex
 
 const (
@@ -21,6 +20,10 @@ const (
 	hide_warnings                  = '-hide-warnings' in os.args || '-w' in os.args
 	show_progress                  = os.getenv('GITHUB_JOB') == '' && '-silent' !in os.args
 	non_option_args                = cmdline.only_non_options(os.args[2..])
+	is_verbose                     = os.getenv('VERBOSE') != ''
+	vcheckfolder                   = os.join_path(os.vtmp_dir(), 'v', 'vcheck_${os.getuid()}')
+	should_autofix                 = os.getenv('VAUTOFIX') != ''
+	vexe                           = @VEXE
 )
 
 struct CheckResult {
@@ -40,13 +43,14 @@ fn (v1 CheckResult) + (v2 CheckResult) CheckResult {
 
 fn main() {
 	if non_option_args.len == 0 || '-help' in os.args {
-		vhelp.show_topic('check-md')
+		help.print_and_exit('check-md')
 		exit(0)
 	}
 	if '-all' in os.args {
 		println('´-all´ flag is deprecated. Please use ´v check-md .´ instead.')
 		exit(1)
 	}
+	mut skip_line_length_check := '-skip-line-length-check' in os.args
 	if show_progress {
 		// this is intended to be replaced by the progress lines
 		println('')
@@ -56,6 +60,10 @@ fn main() {
 	if term_colors {
 		os.setenv('VCOLORS', 'always', true)
 	}
+	os.mkdir_all(vcheckfolder, mode: 0o700) or {} // keep directory private
+	defer {
+		os.rmdir_all(vcheckfolder) or {}
+	}
 	for i := 0; i < files_paths.len; i++ {
 		file_path := files_paths[i]
 		if os.is_dir(file_path) {
@@ -64,21 +72,22 @@ fn main() {
 		}
 		real_path := os.real_path(file_path)
 		lines := os.read_lines(real_path) or {
-			println('"$file_path" does not exist')
+			println('"${file_path}" does not exist')
 			res.warnings++
 			continue
 		}
 		mut mdfile := MDFile{
+			skip_line_length_check: skip_line_length_check
 			path: file_path
 			lines: lines
 		}
 		res += mdfile.check()
 	}
 	if res.errors == 0 && show_progress {
-		term.clear_previous_line()
+		clear_previous_line()
 	}
 	if res.warnings > 0 || res.errors > 0 || res.oks > 0 {
-		println('\nWarnings: $res.warnings | Errors: $res.errors | OKs: $res.oks')
+		println('\nWarnings: ${res.warnings} | Errors: ${res.errors} | OKs: ${res.oks}')
 	}
 	if res.errors > 0 {
 		exit(1)
@@ -89,7 +98,8 @@ fn md_file_paths(dir string) []string {
 	mut files_to_check := []string{}
 	md_files := os.walk_ext(dir, '.md')
 	for file in md_files {
-		if file.contains_any_substr(['/thirdparty/', 'CHANGELOG']) {
+		nfile := file.replace('\\', '/')
+		if nfile.contains_any_substr(['/thirdparty/', 'CHANGELOG']) {
 			continue
 		}
 		files_to_check << file
@@ -123,17 +133,15 @@ fn rtext(s string) string {
 }
 
 fn wline(file_path string, lnumber int, column int, message string) string {
-	return btext('$file_path:${lnumber + 1}:${column + 1}:') + btext(mtext(' warn:')) +
-		rtext(' $message')
+	return btext('${file_path}:${lnumber + 1}:${column + 1}:') + btext(mtext(' warn:')) +
+		rtext(' ${message}')
 }
 
 fn eline(file_path string, lnumber int, column int, message string) string {
-	return btext('$file_path:${lnumber + 1}:${column + 1}:') + btext(rtext(' error: $message'))
+	return btext('${file_path}:${lnumber + 1}:${column + 1}:') + btext(rtext(' error: ${message}'))
 }
 
-const (
-	default_command = 'compile'
-)
+const default_command = 'compile'
 
 struct VCodeExample {
 mut:
@@ -150,9 +158,10 @@ enum MDFileParserState {
 }
 
 struct MDFile {
-	path  string
-	lines []string
+	path                   string
+	skip_line_length_check bool
 mut:
+	lines    []string
 	examples []VCodeExample
 	current  VCodeExample
 	state    MDFileParserState = .markdown
@@ -160,8 +169,8 @@ mut:
 
 fn (mut f MDFile) progress(message string) {
 	if show_progress {
-		term.clear_previous_line()
-		println('File: ${f.path:-30s}, Lines: ${f.lines.len:5}, $message')
+		clear_previous_line()
+		println('File: ${f.path:-30s}, Lines: ${f.lines.len:5}, ${message}')
 	}
 }
 
@@ -170,34 +179,36 @@ fn (mut f MDFile) check() CheckResult {
 	mut anchor_data := AnchorData{}
 	for j, line in f.lines {
 		// f.progress('line: $j')
-		if f.state == .vexample {
-			if line.len > too_long_line_length_example {
-				wprintln(wline(f.path, j, line.len, 'example lines must be less than $too_long_line_length_example characters'))
-				wprintln(line)
-				res.warnings++
+		if !f.skip_line_length_check {
+			if f.state == .vexample {
+				if line.len > too_long_line_length_example {
+					wprintln(wline(f.path, j, line.len, 'example lines must be less than ${too_long_line_length_example} characters'))
+					wprintln(line)
+					res.warnings++
+				}
+			} else if f.state == .codeblock {
+				if line.len > too_long_line_length_codeblock {
+					wprintln(wline(f.path, j, line.len, 'code lines must be less than ${too_long_line_length_codeblock} characters'))
+					wprintln(line)
+					res.warnings++
+				}
+			} else if line.starts_with('|') {
+				if line.len > too_long_line_length_table {
+					wprintln(wline(f.path, j, line.len, 'table lines must be less than ${too_long_line_length_table} characters'))
+					wprintln(line)
+					res.warnings++
+				}
+			} else if line.contains('http') {
+				if line.all_after('https').len > too_long_line_length_link {
+					wprintln(wline(f.path, j, line.len, 'link lines must be less than ${too_long_line_length_link} characters'))
+					wprintln(line)
+					res.warnings++
+				}
+			} else if line.len > too_long_line_length_other {
+				eprintln(eline(f.path, j, line.len, 'must be less than ${too_long_line_length_other} characters'))
+				eprintln(line)
+				res.errors++
 			}
-		} else if f.state == .codeblock {
-			if line.len > too_long_line_length_codeblock {
-				wprintln(wline(f.path, j, line.len, 'code lines must be less than $too_long_line_length_codeblock characters'))
-				wprintln(line)
-				res.warnings++
-			}
-		} else if line.starts_with('|') {
-			if line.len > too_long_line_length_table {
-				wprintln(wline(f.path, j, line.len, 'table lines must be less than $too_long_line_length_table characters'))
-				wprintln(line)
-				res.warnings++
-			}
-		} else if line.contains('http') {
-			if line.all_after('https').len > too_long_line_length_link {
-				wprintln(wline(f.path, j, line.len, 'link lines must be less than $too_long_line_length_link characters'))
-				wprintln(line)
-				res.warnings++
-			}
-		} else if line.len > too_long_line_length_other {
-			eprintln(eline(f.path, j, line.len, 'must be less than $too_long_line_length_other characters'))
-			eprintln(line)
-			res.errors++
 		}
 		if f.state == .markdown {
 			anchor_data.add_links(j, line)
@@ -219,7 +230,7 @@ fn (mut f MDFile) parse_line(lnumber int, line string) {
 			if command == '' {
 				command = default_command
 			} else if command == 'nofmt' {
-				command += ' $default_command'
+				command += ' ${default_command}'
 			}
 			f.current = VCodeExample{
 				sline: lnumber
@@ -326,14 +337,14 @@ fn (mut ad AnchorData) check_link_target_match(fpath string, mut res CheckResult
 				found_error_warning = true
 				res.errors++
 				for anchordata in ad.anchors[link] {
-					eprintln(eline(fpath, anchordata.line, 0, 'multiple link targets of existing link (#$link)'))
+					eprintln(eline(fpath, anchordata.line, 0, 'multiple link targets of existing link (#${link})'))
 				}
 			}
 		} else {
 			found_error_warning = true
 			res.errors++
 			for brokenlink in linkdata {
-				eprintln(eline(fpath, brokenlink.line, 0, 'no link target found for existing link [$brokenlink.lable](#$link)'))
+				eprintln(eline(fpath, brokenlink.line, 0, 'no link target found for existing link [${brokenlink.lable}](#${link})'))
 			}
 		}
 	}
@@ -349,7 +360,7 @@ fn (mut ad AnchorData) check_link_target_match(fpath string, mut res CheckResult
 							anchor.line
 						}
 					}
-					wprintln(wline(fpath, line, 0, 'multiple link target for non existing link (#$link)'))
+					wprintln(wline(fpath, line, 0, 'multiple link target for non existing link (#${link})'))
 					found_error_warning = true
 					res.warnings++
 				}
@@ -389,11 +400,12 @@ fn create_ref_link(s string) string {
 
 fn (mut f MDFile) debug() {
 	for e in f.examples {
-		eprintln('f.path: $f.path | example: $e')
+		eprintln('f.path: ${f.path} | example: ${e}')
 	}
 }
 
 fn cmdexecute(cmd string) int {
+	verbose_println(cmd)
 	res := os.execute(cmd)
 	if res.exit_code < 0 {
 		return 1
@@ -405,6 +417,7 @@ fn cmdexecute(cmd string) int {
 }
 
 fn silent_cmdexecute(cmd string) int {
+	verbose_println(cmd)
 	res := os.execute(cmd)
 	return res.exit_code
 }
@@ -416,8 +429,7 @@ fn get_fmt_exit_code(vfile string, vexe string) int {
 fn (mut f MDFile) check_examples() CheckResult {
 	mut errors := 0
 	mut oks := 0
-	vexe := pref.vexe_path()
-	for e in f.examples {
+	recheck_all_examples: for e in f.examples {
 		if e.command == 'ignore' {
 			continue
 		}
@@ -426,7 +438,9 @@ fn (mut f MDFile) check_examples() CheckResult {
 		}
 		fname := os.base(f.path).replace('.md', '_md')
 		uid := rand.ulid()
-		vfile := os.join_path(os.temp_dir(), 'check_${fname}_example_${e.sline}__${e.eline}__${uid}.v')
+		cfile := os.join_path(vcheckfolder, '${uid}.c')
+		vfile := os.join_path(vcheckfolder, 'check_${fname}_example_${e.sline}__${e.eline}__${uid}.v')
+		efile := os.join_path(vcheckfolder, 'check_${fname}_example_${e.sline}__${e.eline}__${uid}.exe')
 		mut should_cleanup_vfile := true
 		// eprintln('>>> checking example $vfile ...')
 		vcontent := e.text.join('\n') + '\n'
@@ -434,18 +448,37 @@ fn (mut f MDFile) check_examples() CheckResult {
 		mut acommands := e.command.split(' ')
 		nofmt := 'nofmt' in acommands
 		for command in acommands {
-			f.progress('example from $e.sline to $e.eline, command: $command')
+			f.progress('example from ${e.sline} to ${e.eline}, command: ${command}')
 			fmt_res := if nofmt { 0 } else { get_fmt_exit_code(vfile, vexe) }
 			match command {
 				'compile' {
-					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -o x.c ${os.quoted_path(vfile)}')
-					os.rm('x.c') or {}
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -o ${os.quoted_path(efile)} ${os.quoted_path(vfile)}')
 					if res != 0 || fmt_res != 0 {
 						if res != 0 {
 							eprintln(eline(f.path, e.sline, 0, 'example failed to compile'))
 						}
-						if fmt_res != 0 {
-							eprintln(eline(f.path, e.sline, 0, 'example is not formatted'))
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
+						}
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'cgen' {
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -o ${os.quoted_path(cfile)} ${os.quoted_path(vfile)}')
+					if res != 0 || fmt_res != 0 {
+						if res != 0 {
+							eprintln(eline(f.path, e.sline, 0, 'example failed to generate C code'))
+						}
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
 						}
 						eprintln(vcontent)
 						should_cleanup_vfile = false
@@ -455,14 +488,15 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'globals' {
-					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -enable-globals -o x.c ${os.quoted_path(vfile)}')
-					os.rm('x.c') or {}
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -enable-globals -o ${os.quoted_path(cfile)} ${os.quoted_path(vfile)}')
 					if res != 0 || fmt_res != 0 {
 						if res != 0 {
 							eprintln(eline(f.path, e.sline, 0, '`example failed to compile with -enable-globals'))
 						}
-						if fmt_res != 0 {
-							eprintln(eline(f.path, e.sline, 0, '`example is not formatted'))
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
 						}
 						eprintln(vcontent)
 						should_cleanup_vfile = false
@@ -472,13 +506,33 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'live' {
-					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -live -o x.c ${os.quoted_path(vfile)}')
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -live -o ${os.quoted_path(cfile)} ${os.quoted_path(vfile)}')
 					if res != 0 || fmt_res != 0 {
 						if res != 0 {
 							eprintln(eline(f.path, e.sline, 0, 'example failed to compile with -live'))
 						}
-						if fmt_res != 0 {
-							eprintln(eline(f.path, e.sline, 0, 'example is not formatted'))
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
+						}
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'shared' {
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -shared -o ${os.quoted_path(cfile)} ${os.quoted_path(vfile)}')
+					if res != 0 || fmt_res != 0 {
+						if res != 0 {
+							eprintln(eline(f.path, e.sline, 0, 'module example failed to compile with -shared'))
+						}
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
 						}
 						eprintln(vcontent)
 						should_cleanup_vfile = false
@@ -488,14 +542,15 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'failcompile' {
-					res := silent_cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -o x.c ${os.quoted_path(vfile)}')
-					os.rm('x.c') or {}
+					res := silent_cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -o ${os.quoted_path(cfile)} ${os.quoted_path(vfile)}')
 					if res == 0 || fmt_res != 0 {
 						if res == 0 {
 							eprintln(eline(f.path, e.sline, 0, '`failcompile` example compiled'))
 						}
-						if fmt_res != 0 {
-							eprintln(eline(f.path, e.sline, 0, 'example is not formatted'))
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
 						}
 						eprintln(vcontent)
 						should_cleanup_vfile = false
@@ -510,8 +565,24 @@ fn (mut f MDFile) check_examples() CheckResult {
 						if res != 0 {
 							eprintln(eline(f.path, e.sline, 0, '`oksyntax` example with invalid syntax'))
 						}
-						if fmt_res != 0 {
-							eprintln(eline(f.path, e.sline, 0, '`oksyntax` example is not formatted'))
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
+						}
+						eprintln(vcontent)
+						should_cleanup_vfile = false
+						errors++
+						continue
+					}
+					oks++
+				}
+				'okfmt' {
+					if fmt_res != 0 {
+						f.report_not_formatted_example_if_needed(e, fmt_res, vfile) or {
+							unsafe {
+								goto recheck_all_examples
+							}
 						}
 						eprintln(vcontent)
 						should_cleanup_vfile = false
@@ -532,13 +603,21 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'nofmt' {}
+				// mark the example as playable inside docs
+				'play' {}
+				// same as play, but run example as a test
+				'play-test' {}
+				// when ```vmod
+				'mod' {}
 				else {
-					eprintln(eline(f.path, e.sline, 0, 'unrecognized command: "$command", use one of: wip/ignore/compile/failcompile/oksyntax/badsyntax'))
+					eprintln(eline(f.path, e.sline, 0, 'unrecognized command: "${command}", use one of: wip/ignore/compile/failcompile/okfmt/nofmt/oksyntax/badsyntax/cgen/globals/live/shared'))
 					should_cleanup_vfile = false
 					errors++
 				}
 			}
 		}
+		os.rm(cfile) or {}
+		os.rm(efile) or {}
 		if should_cleanup_vfile {
 			os.rm(vfile) or { panic(err) }
 		}
@@ -548,3 +627,65 @@ fn (mut f MDFile) check_examples() CheckResult {
 		oks: oks
 	}
 }
+
+fn verbose_println(message string) {
+	if is_verbose {
+		println(message)
+	}
+}
+
+fn clear_previous_line() {
+	if is_verbose {
+		return
+	}
+	term.clear_previous_line()
+}
+
+fn (mut f MDFile) report_not_formatted_example_if_needed(e VCodeExample, fmt_res int, vfile string) ! {
+	if fmt_res == 0 {
+		return
+	}
+	eprintln(eline(f.path, e.sline, 0, 'example is not formatted'))
+	if !should_autofix {
+		return
+	}
+	f.autofix_example(e, vfile) or {
+		if err is ExampleWasRewritten {
+			eprintln('>> f.path: ${f.path} | example from ${e.sline} to ${e.eline} was re-formated by vfmt')
+			return err
+		}
+		eprintln('>> f.path: ${f.path} | encountered error while autofixing the example: ${err}')
+	}
+}
+
+struct ExampleWasRewritten {
+	Error
+}
+
+fn (mut f MDFile) autofix_example(e VCodeExample, vfile string) ! {
+	eprintln('>>> AUTOFIXING f.path: ${f.path} | e.sline: ${e.sline} | vfile: ${vfile}')
+	res := cmdexecute('${os.quoted_path(vexe)} fmt -w ${os.quoted_path(vfile)}')
+	if res != 0 {
+		return error('could not autoformat the example')
+	}
+	formatted_content_lines := os.read_lines(vfile) or { return }
+	mut new_lines := []string{}
+	new_lines << f.lines#[0..e.sline + 1]
+	new_lines << formatted_content_lines
+	new_lines << f.lines#[e.eline..]
+	f.update_examples(new_lines)!
+	os.rm(vfile) or {}
+	f.examples = f.examples.filter(it.sline >= e.sline)
+	return ExampleWasRewritten{}
+}
+
+fn (mut f MDFile) update_examples(new_lines []string) ! {
+	os.write_file(f.path, new_lines.join('\n'))!
+	f.lines = new_lines
+	f.examples = []
+	f.current = VCodeExample{}
+	f.state = .markdown
+	for j, line in f.lines {
+		f.parse_line(j, line)
+	}
+}

cmd/tools/vcomplete.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2023 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
 //
@@ -76,7 +76,7 @@ SUBCMD:
 
 // Snooped from cmd/v/v.v, vlib/v/pref/pref.v
 const (
-	auto_complete_commands     = [
+	auto_complete_commands      = [
 		// simple_cmd
 		'ast',
 		'doc',
@@ -95,6 +95,7 @@ const (
 		'doctor',
 		'fmt',
 		'gret',
+		'ls',
 		'repl',
 		'self',
 		'setup-freetype',
@@ -114,7 +115,6 @@ const (
 		'help',
 		'new',
 		'init',
-		'complete',
 		'translate',
 		'self',
 		'search',
@@ -130,8 +130,13 @@ const (
 		'run',
 		'build',
 		'build-module',
+		'missdoc',
 	]
-	auto_complete_flags        = [
+	// Entries in the flag arrays below should be entered as is:
+	// * Short flags, e.g.: "-v", should be entered: '-v'
+	// * Long flags, e.g.: "--version", should be entered: '--version'
+	// * Single-dash flags, e.g.: "-version", should be entered: '-version'
+	auto_complete_flags         = [
 		'-apk',
 		'-show-timings',
 		'-check-syntax',
@@ -150,6 +155,7 @@ const (
 		'-autofree',
 		'-compress',
 		'-freestanding',
+		'-no-parallel',
 		'-no-preludes',
 		'-prof',
 		'-profile',
@@ -190,7 +196,7 @@ const (
 		'-version',
 		'--version',
 	]
-	auto_complete_flags_doc    = [
+	auto_complete_flags_doc     = [
 		'-all',
 		'-f',
 		'-h',
@@ -203,12 +209,13 @@ const (
 		'-pos',
 		'-no-timestamp',
 		'-inline-assets',
+		'-theme-dir',
 		'-open',
 		'-p',
 		'-s',
 		'-l',
 	]
-	auto_complete_flags_fmt    = [
+	auto_complete_flags_fmt     = [
 		'-c',
 		'-diff',
 		'-l',
@@ -216,7 +223,7 @@ const (
 		'-debug',
 		'-verify',
 	]
-	auto_complete_flags_bin2v  = [
+	auto_complete_flags_bin2v   = [
 		'-h',
 		'--help',
 		'-m',
@@ -226,22 +233,46 @@ const (
 		'-w',
 		'--write',
 	]
-	auto_complete_flags_shader = [
-		'help',
-		'h',
-		'force-update',
-		'u',
-		'verbose',
-		'v',
-		'slang',
-		'l',
-		'output',
-		'o',
+	auto_complete_flags_shader  = [
+		'--help',
+		'-h',
+		'--force-update',
+		'-u',
+		'--verbose',
+		'-v',
+		'--slang',
+		'-l',
+		'--output',
+		'-o',
 	]
-	auto_complete_flags_self   = [
+	auto_complete_flags_missdoc = [
+		'--help',
+		'-h',
+		'--tags',
+		'-t',
+		'--deprecated',
+		'-d',
+		'--private',
+		'-p',
+		'--no-line-numbers',
+		'-n',
+		'--exclude',
+		'-e',
+		'--relative-paths',
+		'-r',
+		'--js',
+		'--verify',
+		'--diff',
+	]
+	auto_complete_flags_bump    = [
+		'--patch',
+		'--minor',
+		'--major',
+	]
+	auto_complete_flags_self    = [
 		'-prod',
 	]
-	auto_complete_compilers    = [
+	auto_complete_compilers     = [
 		'cc',
 		'gcc',
 		'tcc',
@@ -264,12 +295,12 @@ fn auto_complete(args []string) {
 					println(setup_for_shell(shell_name))
 					exit(0)
 				}
-				eprintln('Unknown shell ${shell_name}. Supported shells are: $auto_complete_shells')
+				eprintln('Unknown shell ${shell_name}. Supported shells are: ${auto_complete_shells}')
 				exit(1)
 			}
 			eprintln('auto completion require arguments to work.')
 		} else {
-			eprintln('auto completion failed for "$args".')
+			eprintln('auto completion failed for "${args}".')
 		}
 		exit(1)
 	}
@@ -278,7 +309,7 @@ fn auto_complete(args []string) {
 	match sub {
 		'setup' {
 			if sub_args.len <= 1 || sub_args[1] !in auto_complete_shells {
-				eprintln('please specify a shell to setup auto completion for ($auto_complete_shells).')
+				eprintln('please specify a shell to setup auto completion for (${auto_complete_shells}).')
 				exit(1)
 			}
 			shell := sub_args[1]
@@ -291,7 +322,7 @@ fn auto_complete(args []string) {
 			mut lines := []string{}
 			list := auto_complete_request(sub_args[1..])
 			for entry in list {
-				lines << "COMPREPLY+=('$entry')"
+				lines << "COMPREPLY+=('${entry}')"
 			}
 			println(lines.join('\n'))
 		}
@@ -302,7 +333,7 @@ fn auto_complete(args []string) {
 			mut lines := []string{}
 			list := auto_complete_request(sub_args[1..])
 			for entry in list {
-				lines << '$entry'
+				lines << '${entry}'
 			}
 			println(lines.join('\n'))
 		}
@@ -313,7 +344,7 @@ fn auto_complete(args []string) {
 			mut lines := []string{}
 			list := auto_complete_request(sub_args[1..])
 			for entry in list {
-				lines << 'compadd -U -S' + '""' + ' -- ' + "'$entry';"
+				lines << 'compadd -U -S' + '""' + ' -- ' + "'${entry}';"
 			}
 			println(lines.join('\n'))
 		}
@@ -325,8 +356,8 @@ fn auto_complete(args []string) {
 	exit(0)
 }
 
-// append_separator_if_dir is a utility function.that returns the input `path` appended an
-// OS dependant path separator if the `path` is a directory.
+// append_separator_if_dir returns the input `path` with an appended
+// `/` or `\`, depending on the platform, when `path` is a directory.
 fn append_separator_if_dir(path string) string {
 	if os.is_dir(path) && !path.ends_with(os.path_separator) {
 		return path + os.path_separator
@@ -347,7 +378,7 @@ fn nearest_path_or_root(path string) string {
 	return fixed_path
 }
 
-// auto_complete_request retuns a list of completions resolved from a full argument list.
+// auto_complete_request returns a list of completions resolved from a full argument list.
 fn auto_complete_request(args []string) []string {
 	// Using space will ensure a uniform input in cases where the shell
 	// returns the completion input as a string (['v','run'] vs. ['v run']).
@@ -371,12 +402,17 @@ fn auto_complete_request(args []string) []string {
 			parent_command = parts[i]
 			break
 		}
-		get_flags := fn (base []string, flag string) []string {
-			if flag.len == 1 { return base
-			 } else { return base.filter(it.starts_with(flag))
-			 }
-		}
-		if part.starts_with('-') { // 'v -<tab>' -> flags.
+		if part.starts_with('-') { // 'v [subcmd] -<tab>' or 'v [subcmd] --<tab>'-> flags.
+			get_flags := fn (base []string, flag string) []string {
+				mut results := []string{}
+				for entry in base {
+					if entry.starts_with(flag) {
+						results << entry
+					}
+				}
+				return results
+			}
+
 			match parent_command {
 				'bin2v' { // 'v bin2v -<tab>'
 					list = get_flags(auto_complete_flags_bin2v, part)
@@ -396,6 +432,12 @@ fn auto_complete_request(args []string) []string {
 				'shader' { // 'v shader -<tab>' -> flags.
 					list = get_flags(auto_complete_flags_shader, part)
 				}
+				'missdoc' { // 'v missdoc -<tab>' -> flags.
+					list = get_flags(auto_complete_flags_missdoc, part)
+				}
+				'bump' { // 'v bump -<tab>' -> flags.
+					list = get_flags(auto_complete_flags_bump, part)
+				}
 				else {
 					for flag in auto_complete_flags {
 						if flag == part {
@@ -413,6 +455,11 @@ fn auto_complete_request(args []string) []string {
 					}
 				}
 			}
+			// Clear the list if the result is identical to the part examined
+			// (the flag must have already been completed)
+			if list.len == 1 && part == list[0] {
+				list.clear()
+			}
 		} else {
 			match part {
 				'help' { // 'v help <tab>' -> top level commands except "help".
@@ -471,6 +518,17 @@ fn auto_complete_request(args []string) []string {
 					}
 				}
 			} else {
+				// Handle special case, where there is only one file in the directory
+				// being completed - if it can be resolved we return that since
+				// handling it in the generalized logic below will result in
+				// more complexity.
+				if entries.len == 1 && os.is_file(os.join_path(ls_path, entries[0])) {
+					mut keep_input_path_format := ls_path
+					if !part.starts_with('./') && ls_path.starts_with('./') {
+						keep_input_path_format = keep_input_path_format.all_after('./')
+					}
+					return [os.join_path(keep_input_path_format, entries[0])]
+				}
 				for entry in entries {
 					if collect_all || entry.starts_with(last) {
 						list << append_separator_if_dir(entry)
@@ -495,7 +553,7 @@ _v_completions() {
 	local limit
 	# Send all words up to the word the cursor is currently on
 	let limit=1+\$COMP_CWORD
-	src=\$($vexe complete bash \$(printf "%s\\n" \${COMP_WORDS[@]: 0:\$limit}))
+	src=\$(${vexe} complete bash \$(printf "%s\\n" \${COMP_WORDS[@]: 0:\$limit}))
 	if [[ \$? == 0 ]]; then
 		eval \${src}
 		#echo \${src}
@@ -509,7 +567,7 @@ complete -o nospace -F _v_completions v
 			setup = '
 function __v_completions
 	# Send all words up to the one before the cursor
-	$vexe complete fish (commandline -cop)
+	${vexe} complete fish (commandline -cop)
 end
 complete -f -c v -a "(__v_completions)"
 '
@@ -520,7 +578,7 @@ complete -f -c v -a "(__v_completions)"
 _v() {
 	local src
 	# Send all words up to the word the cursor is currently on
-	src=\$($vexe complete zsh \$(printf "%s\\n" \${(@)words[1,\$CURRENT]}))
+	src=\$(${vexe} complete zsh \$(printf "%s\\n" \${(@)words[1,\$CURRENT]}))
 	if [[ \$? == 0 ]]; then
 		eval \${src}
 		#echo \${src}
@@ -533,7 +591,7 @@ compdef _v v
 			setup = '
 Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
 	param(\$commandName, \$wordToComplete, \$cursorPosition)
-		$vexe complete powershell "\$wordToComplete" | ForEach-Object {
+		${vexe} complete powershell "\$wordToComplete" | ForEach-Object {
 			[System.Management.Automation.CompletionResult]::new(\$_, \$_, \'ParameterValue\', \$_)
 		}
 }