native: enable printing for all supported expressions (#16270)

Make it easier to change later, by splitting the tracing call into its own `v.trace_calls` module, so that it can be iterated upon without changing the compiler itself.

.cirrus.yml

@@ -0,0 +1,18 @@
+freebsd_instance:
+  image_family: freebsd-13-0
+
+freebsd_task:
+  name: Code CI / freebsd
+  install_script: pkg install -y git
+  script: |
+    echo 'Building V'
+    git clone https://github.com/vlang/v
+    cd v
+    make
+    ##.github/workflows/freebsd_build_tcc.sh
+    ##tcc -v -v
+    echo 'Build cmd/tools/fast'
+    cd cmd/tools/fast && ../../../v fast.v && ./fast -clang
+    echo 'Run test-self'
+    cd /tmp/cirrus-ci-build/v
+    VTEST_JUST_ESSENTIAL=1 ./v test-self

.editorconfig

@@ -16,9 +16,14 @@ indent_size = 2
 
 [*.md]
 trim_trailing_whitespace = false
+# lines that are too long will trigger an error in cmd/tools/vcheck-md.v
+# run v check-md [folder/file] to test markdown files
+# the longest normal line is specified with this constant:
+# `too_long_line_length_other     = 100`
+max_line_length = 100
 
 [*.{txt,out}]
 insert_final_newline = false
 
-[Makefile]
+[{Makefile,GNUmakefile}]
 indent_style = tab

.gitattributes

@@ -1,4 +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.md

@@ -14,6 +14,8 @@ assignees: ''
 **V version:** 
 **OS:** 
 
+<!-- Please include the standalone minimal reproducible code.
+If not, it may be closed by the administrators. -->
 **What did you do?**
 
 

.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").
 

.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.temp_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/binary_artifact.yml

@@ -2,206 +2,162 @@ name: Build binary artifacts
 
 on:
   push:
-     tags:
-       - weekly.**
-       - 0.**
+    tags:
+      - weekly.**
+      - 0.**
 
 jobs:
+
   build-linux:
     runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        compiler: [gcc]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Compile
-      env:
-        CC: ${{ matrix.compiler }}
-      run: |
-         make -j4
-         ./v -cc $CC -o v -prod cmd/v 
-         ./v -prod cmd/tools/vup.v 
-         ./v -prod cmd/tools/vdoctor.v
-    - name: Create artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: linux
-        path: |
-          .
-          ./cmd/tools/vup
-          ./cmd/tools/vdoctor
-          !./.git
-          !./vc
-          !./v_old
-    - name: Create binary only artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: linux-binary
-        path: ./v
-  build-linux-arm64:
-    runs-on: ubuntu-20.04
-    strategy:
-      matrix:
-        compiler: [gcc]
     env:
-      img: quay.io/pypa/manylinux2014_aarch64
+      CC: gcc
+      ZIPNAME: v_linux.zip
     steps:
-    - name: Checkout
-      uses: actions/checkout@v1
-    - name: Set up QEMU
-      id: qemu
-      uses: docker/setup-qemu-action@v1
-    - name: Compile
-      env:
-        CC: ${{ matrix.compiler }}
-      run: |
-         docker run --platform=linux/arm64 --rm -v `pwd`:`pwd` -w `pwd` ${{ env.img }} /bin/bash -c "make -j4 && ./v -cc $CC -o v -prod cmd/v && ./v -prod cmd/tools/vup.v && ./v -prod cmd/tools/vdoctor.v"
-    - name: Create artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: linux_arm64
-        path: |
-          .
-          ./cmd/tools/vup
-          ./cmd/tools/vdoctor
-          !./.git
-          !./vc
-          !./v_old
-    - name: Create binary only artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: linux_arm64-binary
-        path: ./v
+      - uses: actions/checkout@v1
+      - name: Compile
+        run: |
+          make -j4
+          ./v -cc $CC -prod -o v cmd/v
+          ./v -cc $CC -prod cmd/tools/vup.v
+          ./v -cc $CC -prod cmd/tools/vdoctor.v
+      - name: Remove excluded
+        run: |
+           rm -rf .git
+           rm -rf vc/
+           rm -rf v_old
+      - name: Create ZIP archive
+        run: |
+           cd ..
+           zip -r9 --symlinks $ZIPNAME v/
+           mv $ZIPNAME v/
+           cd v/
+      - name: Create artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: linux
+          path: v_linux.zip
+
   build-macos:
     runs-on: macos-latest
-    strategy:
-      matrix:
-        compiler: [clang]
+    env:
+      CC: clang
+      ZIPNAME: v_macos.zip
     steps:
-    - uses: actions/checkout@v1
-    - name: Compile
-      env:
-        CC: ${{ matrix.compiler }}
-      run: |
-         make -j4
-         ./v -cc $CC -o v -prod cmd/v 
-         ./v -prod cmd/tools/vup.v 
-         ./v -prod cmd/tools/vdoctor.v
-    - name: Create artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: macos
-        path: |
-          .
-          ./cmd/tools/vup
-          ./cmd/tools/vdoctor
-          !./.git
-          !./vc
-          !./v_old
-    - name: Create binary only artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: macos-binary
-        path: ./v
+      - uses: actions/checkout@v1
+      - name: Compile
+        run: |
+          make -j4
+          ./v -cc $CC -prod -o v cmd/v
+          ./v -cc $CC -prod cmd/tools/vup.v
+          ./v -cc $CC -prod cmd/tools/vdoctor.v
+      - name: Remove excluded
+        run: |
+           rm -rf .git
+           rm -rf vc/
+           rm -rf v_old
+      - name: Create ZIP archive
+        run: |
+           cd ..
+           zip -r9 --symlinks $ZIPNAME v/
+           mv $ZIPNAME v/
+           cd v/
+      - name: Create artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: macos
+          path: v_macos.zip
+
   build-windows:
     runs-on: windows-latest
+    env:
+      CC: msvc
+      ZIPNAME: v_windows.zip
     steps:
-    - uses: actions/checkout@v1
-    - uses: msys2/setup-msys2@v2
-    - name: Compile
-      run: |
-        .\make.bat
-        .\v.exe cmd\tools\vup.v
-        .\v.exe cmd\tools\vdoctor.v
-    - name: Create artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: windows
-        path: |
-          .
-          ./cmd/tools/vup.exe
-          ./cmd/tools/vdoctor.exe
-          !./.git
-          !./vc
-          !./v_old.exe
-    - name: Create binary only artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: windows-binary
-        path: ./v.exe
+      - uses: actions/checkout@v1
+      - uses: msys2/setup-msys2@v2
+      - name: Compile
+        run: |
+          .\make.bat -tcc
+          .\v.exe cmd\tools\vup.v
+          .\v.exe cmd\tools\vdoctor.v
+      - name: Remove excluded
+        shell: msys2 {0}
+        run: |
+           rm -rf .git
+           rm -rf vc/
+           rm -rf v_old.exe
+      - name: Create archive
+        shell: msys2 {0}
+        run: |
+           cd ..
+           powershell Compress-Archive v $ZIPNAME
+           mv $ZIPNAME v/
+           cd v/
+# NB: the powershell Compress-Archive line is from:
+# https://superuser.com/a/1336434/194881
+# It is needed, because `zip` is not installed by default :-|
+      - name: Create artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: windows
+          path: v_windows.zip
 
   release:
     name: Create Github Release
-    needs: [build-linux-arm64, build-linux, build-windows, build-macos]
+    needs: [build-linux, build-windows, build-macos]
     runs-on: ubuntu-20.04
     steps:
-    - name: Get short tag name
-      uses: jungwinter/split@v1
-      id: split
-      with:
-        msg: ${{ github.ref }}
-        seperator: /
-    - name: Create Release
-      id: create_release
-      uses: ncipollo/release-action@v1
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        tag: ${{ steps.split.outputs._2 }}
-        name: ${{ steps.split.outputs._2 }}
-        commit: ${{ github.sha }}
-        draft: false
-        prerelease: false
+      - name: Get short tag name
+        uses: jungwinter/split@v1
+        id: split
+        with:
+          msg: ${{ github.ref }}
+          seperator: /
+      - name: Create Release
+        id: create_release
+        uses: ncipollo/release-action@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ steps.split.outputs._2 }}
+          name: ${{ steps.split.outputs._2 }}
+          commit: ${{ github.sha }}
+          draft: false
+          prerelease: false
 
   publish:
     needs: [release]
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        version: [linux_arm64, linux, macos, windows]
+        version: [linux, macos, windows]
     steps:
-    - uses: actions/checkout@v1
-    - name: Fetch artifacts
-      uses: actions/download-artifact@v1
-      with:
-        name: ${{ matrix.version }}
-        path: ./${{ matrix.version }}
-    - name: Build Zip Archives
-      run: |
-           mkdir -p workdir/
-           mv ${{ matrix.version }}/ workdir/v/
-           cd workdir/v/
-           chmod 755 v || true
-           chmod 755 v.exe || true
-           chmod 755 thirdparty/tcc/tcc.exe || true
-           chmod 755 cmd/tools/vup || true
-           chmod 755 cmd/tools/vup.exe || true
-           chmod 755 cmd/tools/vdoctor || true
-           chmod 755 cmd/tools/vdoctor.exe || true
-           rm -rf v_old v_old.exe
-           cd ..
-           zip -r9 --symlinks ../v_${{ matrix.version }}.zip v/*
-           cd ..
-           rm -rf workdir/
-    - name: Get short tag name
-      uses: jungwinter/split@v1
-      id: split
-      with:
-        msg: ${{ github.ref }}
-        seperator: /
-    - name: Get release
-      id: get_release_info
-      uses: leahlundqvist/get-release@v1.3.1
-      env:
-        GITHUB_TOKEN: ${{ github.token }}
-      with:
-        tag_name: ${{ steps.split.outputs._2 }}
-    - name: Upload Release Asset
-      id: upload-release-asset
-      uses: actions/upload-release-asset@v1.0.1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.get_release_info.outputs.upload_url }}
-        asset_path: ./v_${{ matrix.version }}.zip
-        asset_name: v_${{ matrix.version }}.zip
-        asset_content_type: application/zip
+      - uses: actions/checkout@v1
+      - name: Fetch artifacts
+        uses: actions/download-artifact@v1
+        with:
+          name: ${{ matrix.version }}
+          path: ./${{ matrix.version }}
+      - name: Get short tag name
+        uses: jungwinter/split@v1
+        id: split
+        with:
+          msg: ${{ github.ref }}
+          seperator: /
+      - name: Get release
+        id: get_release_info
+        uses: leahlundqvist/get-release@v1.3.1
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        with:
+          tag_name: ${{ steps.split.outputs._2 }}
+      - name: Upload Release Asset
+        id: upload-release-asset
+        uses: actions/upload-release-asset@v1.0.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.get_release_info.outputs.upload_url }}
+          asset_path: ${{ matrix.version }}/v_${{ matrix.version }}.zip
+          asset_name: v_${{ matrix.version }}.zip
+          asset_content_type: application/zip

.github/workflows/c2v.yml

@@ -0,0 +1,132 @@
+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@v2
+      - 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
+    steps:
+      - uses: actions/checkout@v2
+      - 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 &
+          sleep 1 # give xvfb time to start
+          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/cancel.yml

@@ -2,7 +2,7 @@ name: Cancel previous workflows
 
 on:
   workflow_run:
-    workflows: ["Code CI", "Sanitized CI"] # the other workflows finish quickly - no need to skip them for now
+    workflows: ["Code CI"]
     types:
       - requested
 
@@ -14,4 +14,5 @@ jobs:
       # don't cancel CI for commits pushed to vlang/v#master (if ci is still too slow, this can be removed safely)
       if: ${{ github.event.workflow_run.head_repository.full_name != 'vlang/v' || github.event.workflow_run.head_branch != 'master' }}
       with:
-        workflow_id: ${{ github.event.workflow.id }}
+        # workflow ids for `Code CI` and `Sanitized CI` (from https://api.github.com/repos/vlang/v/actions/workflows):
+        workflow_id: 4577,7940868 # the other workflows finish quickly - no need to skip them

.github/workflows/ci.yml

@@ -4,52 +4,21 @@ on:
   push:
     paths-ignore:
       - "**.md"
+      - "**.yml"
   pull_request:
     paths-ignore:
       - "**.md"
+      - "**.yml"
+
+concurrency:
+  group: build-ci-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
 
 jobs:
-  no-scheduling:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Dont schedule all jobs
-        run: sleep 10
-
-  code-formatting-perf-regressions:
-    needs: no-scheduling
-    runs-on: ubuntu-20.04
-    timeout-minutes: 15
-    env:
-      VFLAGS: -cc gcc
-    steps:
-      - uses: actions/checkout@v2
-      - 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
-      - name: v test-fmt
-        run: ./v -silent test-fmt
-
-  ## Performance regressions
-      - name: Clone & Build vmaster/v
-        run: |
-          git clone --depth=1 https://github.com/vlang/v vmaster/
-          (cd vmaster; make -j4)
-      - name: V versions
-        run: ./v version && ./vmaster/v version
-      - name: Build the repeat tool
-        run: ./v cmd/tools/repeat.v
-      - name: Repeat -o hw.c examples/hello_world.v
-        run: cmd/tools/repeat --max_time 201 --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 1201 --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
-
   ubuntu-tcc:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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:
@@ -62,11 +31,13 @@ jobs:
           ## 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
@@ -75,7 +46,7 @@ jobs:
         run: |
           thirdparty/tcc/tcc.exe -version
           ./v -cg -o v cmd/v # Make sure vtcc can build itself twice
-      #        ./v -silent test-all
+      #        ./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
@@ -85,12 +56,15 @@ jobs:
           ./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 -silent test-self
+        run: ./v test-self
       # - name: Self tests (-cstrict)
-      #   run: ./v -cstrict test-self
+      #   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
@@ -107,16 +81,30 @@ jobs:
         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
+        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
+
 
   ubuntu-tcc-boehm-gc:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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:
@@ -150,131 +138,33 @@ jobs:
         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 -silent test-self
+        run: ./v -gc boehm test-self
       - name: Test leak detector
         run: |
-          ./v -gc boehm_leak -o testcase_leak vlib/v/tests/testcase_leak.v
+          ./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
+          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.v
+          ./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.v
+          ./v -o testcase_leak vlib/v/tests/testcase_leak.vv
           ./testcase_leak 2>leaks.txt
           [ "$(stat -c %s leaks.txt)" = "0" ]
 
-  misc-tooling:
-    needs: no-scheduling
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    env:
-      VFLAGS: -cc tcc -no-retry-compilation
-    steps:
-      - uses: actions/checkout@v2
-        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
-      - name: Build v
-        run: make
-
-      - 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 -w -o v_from_vc /tmp/v.c  -lm -lpthread
-          ls -lart v_from_vc
-          ./v_from_vc version
-
-      - name: Ensure v up works
-        run: |
-          ./v cmd/tools/oldv.v
-          ./cmd/tools/oldv -v HEAD^^^^^
-          cd ~/.cache/oldv/v_at_HEAD_____/
-          ./v version
-          ./v -v up
-          ./v version
-          ./v  -o v2 cmd/v
-          ./v2 -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
-
-      - name: Shader examples can be build
-        run: |
-          wget https://github.com/floooh/sokol-tools-bin/raw/master/bin/linux/sokol-shdc
-          chmod +x ./sokol-shdc
-          for f in examples/sokol/02_cubes_glsl/cube_glsl \
-              examples/sokol/03_march_tracing_glsl/rt_glsl \
-              examples/sokol/04_multi_shader_glsl/rt_glsl_puppy \
-              examples/sokol/04_multi_shader_glsl/rt_glsl_march \
-              examples/sokol/05_instancing_glsl/rt_glsl_instancing \
-              examples/sokol/06_obj_viewer/gouraud \
-              ; do \
-                 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 -o v2 cmd/v && ./v2 -cc g++-9 -o v3 cmd/v
-  ##    - name: Running tests with g++
-  ##      run: ./v -cc g++-9 -silent test-self
-
-
-  alpine-docker-musl-gcc:
-    needs: no-scheduling
-    name: alpine-musl
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    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: Build V
-        run: |
-          make CC=clang
-      - name: Show PWD and Environment
-        run: |
-          echo "PWD:"
-          pwd
-          echo "ENVIRONMENT"
-          env
-      - name: Test V fixed tests
-        run: |
-          ./v -silent test-self
-
   macos:
-    needs: no-scheduling
-    runs-on: macOS-latest
-    timeout-minutes: 60
+    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/openssl@3/lib/pkgconfig
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
@@ -284,8 +174,9 @@ jobs:
         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
+          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
@@ -294,12 +185,6 @@ jobs:
           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
-# QTODO
-#      - name: v self compilation with -usecache
-#        run: |
-#          ./v -o v2 -usecache cmd/v
-#          ./v2 -o v3 -usecache cmd/v
-#          ./v3 -usecache examples/tetris/tetris.v
       - name: Test symlink
         run: ./v symlink
       #    - name: Set up pg database
@@ -309,22 +194,22 @@ jobs:
       #        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
+      #      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 -silent test-self
-
+        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
@@ -332,14 +217,13 @@ jobs:
       - 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
@@ -348,7 +232,6 @@ jobs:
 #          ../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
@@ -356,12 +239,27 @@ jobs:
           mkdir -p ~/.vmodules
           ln -s $(pwd) ~/.vmodules/ui
           ../v examples/rectangles.v
-          ../v run examples/build_examples.vsh
+          ## ../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
 
   ubuntu:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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/setup-node@v1
@@ -383,42 +281,49 @@ jobs:
           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
+      #      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 . && 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
+      - name: V self compilation
         run: ./v -o v2 cmd/v && ./v2 -o v3 cmd/v && ./v3 -o v4 cmd/v
-# QTODO
-#      - name: v self compilation with -usecache
-#        run: |
-#          ./v -o v2 -usecache cmd/v
-#          ./v2 -o v3 -usecache cmd/v
-#          ./v3 -usecache examples/tetris/tetris.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 -silent test-self
+        run: ./v test-self
       - name: Self tests (-prod)
-        run: ./v -o vprod -prod cmd/v && ./vprod -silent test-self
+        run: ./v -o vprod -prod cmd/v && ./vprod test-self
       - name: Self tests (-cstrict)
-        run: ./v -cc gcc -cstrict test-self
+        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
@@ -448,16 +353,16 @@ jobs:
           ls
 
   #        ./1m
-  #run: echo "TODO" #cd examples/native && ../../v -native hello_world.v && ./hello_world
+  # 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:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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:
@@ -487,23 +392,31 @@ jobs:
           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
-# QTODO
-#      - name: v self compilation with -usecache
-#        run: |
-#          ./v -o v2 -usecache cmd/v
-#          ./v2 -o v3 -usecache cmd/v
-#          ./v3 -usecache examples/tetris/tetris.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 -silent test-self
-      - name: Self tests (-prod)
-        run: ./v -o vprod -prod cmd/v && ./vprod -silent test-self
+          ./v -o vprod -prod cmd/v
+          ./vprod test-self
       - name: Self tests (-cstrict)
-        run: ./v -cstrict test-self
+        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
@@ -537,78 +450,13 @@ jobs:
           echo "Running it..."
           ls
 
-  #  ubuntu-autofree-selfcompile:
-  #    runs-on: ubuntu-20.04
-  #    timeout-minutes: 60
-  #    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 docker pre-built container
-  ubuntu-musl:
-    needs: no-scheduling
-    name: ubuntu-musl
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    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: |
-          ./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
-
-  #   ubuntu-musl:
-  #     runs-on: ubuntu-20.04
-  #     timeout-minutes: 60
-  #     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
-
   windows-gcc:
-    needs: no-scheduling
     runs-on: windows-2019
-    timeout-minutes: 60
+    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
+      VERBOSE_MAKE: 1
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
@@ -619,7 +467,9 @@ jobs:
           gcc --version
           .\make.bat -gcc
       - name: Test new v.c
-        run: .\v.exe -o v.c cmd/v && gcc -Werror -municode -w v.c
+        run: |
+          .\v.exe -o v.c cmd/v
+          gcc -Werror -municode -w v.c
       - name: Install dependencies
         run: |
           .\v.exe setup-freetype
@@ -629,14 +479,31 @@ jobs:
           ./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: |
-          .\v.exe -silent test-self
-  #    - name: Test
-  #      run: |
-  #        .\v.exe -silent test-all
+          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
@@ -647,11 +514,12 @@ jobs:
         run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
 
   windows-msvc:
-    needs: no-scheduling
     runs-on: windows-2019
-    timeout-minutes: 60
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 121
     env:
       VFLAGS: -cc msvc
+      VERBOSE_MAKE: 1
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v1
@@ -661,7 +529,7 @@ jobs:
         run: |
           echo %VFLAGS%
           echo $VFLAGS
-          .\make.bat -msvc --verbose
+          .\make.bat -msvc
           .\v.exe -cflags /WX self
       - name: Install dependencies
         run: |
@@ -672,15 +540,18 @@ jobs:
           ./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 -silent test-self
+          ./v test-self
   #    - name: Test
-  #      run: |
-  #        .\v.exe -silent test-all
+  #      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
@@ -691,13 +562,14 @@ jobs:
         run: .\v.exe -o v2.exe cmd/v && .\v2.exe -o v3.exe cmd/v
 
   windows-tcc:
-    needs: no-scheduling
     runs-on: windows-2019
-    timeout-minutes: 60
+    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@v2
       - uses: actions/setup-node@v1
@@ -705,9 +577,11 @@ jobs:
           node-version: 12.x
       - name: Build with make.bat -tcc
         run: |
-          .\make.bat -tcc --verbose
+          .\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
+        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
@@ -719,54 +593,17 @@ jobs:
         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 --verbose
-      - name: Test new v.c
-        run: .\v.exe -o v.c cmd/v && .\thirdparty\tcc\tcc.exe -Werror -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: 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: All code is formatted
+        run: ./v test-cleancode
       - name: Self tests
         run: ./v test-self
       - name: Test v->js
@@ -776,110 +613,87 @@ jobs:
       - 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
+        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
 
-  parser-silent:
-    needs: no-scheduling
-    name: Parser silent mode
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install zzuf
-        run: sudo apt install -qq zzuf
-      - name: Build local v
-        run: |
-          make -j4
-          ./v -g cmd/tools/vtest-parser.v
-      - name: Run test-parser
-        run: |
-          ./v test-parser -S examples/hello_world.v
-          ./v test-parser -S examples/hanoi.v
-          ./v test-parser -S examples/fibonacci.v
-          ./v test-parser -S examples/cli.v
-          ./v test-parser -S examples/json.v
-          ./v test-parser -S examples/vmod.v
-          ./v test-parser -S examples/regex/regex_example.v
-          ./v test-parser -S examples/2048/2048.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
 
-      - name: Run test-parser over fuzzed files
-        run: |
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/hello_world.v > examples/hello_world_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/hanoi.v > examples/hanoi_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/fibonacci.v > examples/fibonacci_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/cli.v > examples/cli_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/json.v > examples/json_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/vmod.v > examples/vmod_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/regex/regex_example.v > examples/regex_example_fuzz.v
-          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/2048/2048.v > examples/2048/2048_fuzz.v
-          ./v test-parser -S examples/hello_world_fuzz.v
-          ./v test-parser -S examples/hanoi_fuzz.v
-          ./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:
-    needs: no-scheduling
-    runs-on: ubuntu-20.04
-    timeout-minutes: 60
-    steps:
-      - uses: actions/checkout@v2
-      - name: Build V
-        run: make && sudo ./v symlink
+#  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@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
 
-  ## vls
-      - name: Clone tree-sitter-v to ~/.vmodules/tree_sitter_v
-        run: git clone --depth 1 https://github.com/nedpals/tree-sitter-v ~/.vmodules/tree_sitter_v
-      - name: Clone VLS tree-sitter
-        run: git clone --depth 1 --no-single-branch https://github.com/vlang/vls
-      - name: Checkout branch tree-sitter
-        run: pushd vls; git checkout use-tree-sitter; popd
-      - name: Build VLS tree-sitter
-        run: pushd vls; v cmd/vls ; popd
-      - name: Build VLS tree-sitter with -prod
-        run: pushd vls; v -prod cmd/vls; popd
-      - name: Checkout branch master
-        run: pushd vls; git checkout master; popd
-      - name: Build VLS master
-        run: pushd vls; v cmd/vls ; popd
-      - name: Build VLS master with -prod
-        run: pushd vls; v -prod cmd/vls ; popd
 
-  ## vab
-      - name: Clone vab
-        run: git clone --depth 1 https://github.com/vlang/vab
-      - name: Build vab
-        run: cd vab; ../v ./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 .
-          ../v -autofree .
-          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: 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
+#   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@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 test-self

.github/workflows/ci_bootstrapping_works.yml

@@ -0,0 +1,75 @@
+name: Bootstraping works
+
+on:
+  schedule:
+    - cron: '0 */6 * * *'
+
+jobs:
+  ubuntu:
+    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=c99 -w
+      B_LFLAGS: -lm -lpthread
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 10
+      - name: Build v
+        run: make
+
+      - name: v.c can be compiled and run with -os cross (bootstrapping works)
+        run: |
+          ls -la v vc/v.c
+          ./v -os cross -o vc/v.c cmd/v
+          gcc $B_CFLAGS -o v_from_vc vc/v.c $B_LFLAGS
+          ls -lart v_from_vc
+          ./v_from_vc version
+          ./v_from_vc run examples/hello_world.v
+          ./v_from_vc -o v_from_vc_produced_native_v cmd/v
+          ./v_from_vc_produced_native_v run examples/hello_world.v
+          make local=1
+          ls -la v vc/v.c v_from_vc v_from_vc_produced_native_v
+
+      - name: Ensure v up works
+        run: |
+          ./v cmd/tools/oldv.v
+          ./cmd/tools/oldv -v HEAD^^^^^
+          cd ~/.cache/oldv/v_at_HEAD_____/
+          ./v version
+          ./v -v up
+          ./v version
+          ./v  -o v2 cmd/v
+          ./v2 -o v3 cmd/v
+
+  macos:
+    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=c99 -w
+      B_LFLAGS: -lm -lpthread
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 10
+      - name: Build V
+        run: make && ./v -cg -cstrict -o v cmd/v
+
+      - name: v.c can be compiled and run with -os cross (bootstrapping works)
+        run: |
+          ls -la v vc/v.c
+          ./v -os cross -o vc/v.c cmd/v
+          cc $B_CFLAGS -o v_from_vc vc/v.c $B_LFLAGS
+          ls -lart v_from_vc
+          ./v_from_vc version
+          ./v_from_vc run examples/hello_world.v
+          ./v_from_vc -o v_from_vc_produced_native_v cmd/v
+          ./v_from_vc_produced_native_v run examples/hello_world.v
+          ### the next make invocation will simulate building V from scratch,
+          ### using this commit
+          make local=1
+          ls -la v vc/v.c v_from_vc v_from_vc_produced_native_v

.github/workflows/ci_cross.yml

@@ -12,30 +12,31 @@ 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
         with:
           fetch-depth: 10
-          
+
       - name: Install dependencies
         run: |
           brew install mingw-w64
           export LIBRARY_PATH="$LIBRARY_PATH:/usr/local/opt/openssl/lib/"
-          
+
       - name: Build V
         run: make
 
       - name: Test symlink
         run: ./v symlink
-        
+
       - name: Cross-compilation to Linux
         run: |
           ./v -os linux cmd/v
           # TODO: fix this: ./v -os linux examples/2048/2048.v
-          
+
       - name: Cross-compilation to Windows
         run: |
           ./v -os windows cmd/v
@@ -43,7 +44,8 @@ jobs:
 
   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:
@@ -52,35 +54,38 @@ jobs:
           fetch-depth: 10
       - name: Install dependencies
         run: |
+          ## sudo dpkg --add-architecture i386
           sudo apt update
-          sudo apt-get install --quiet -y libssl-dev sqlite3 libsqlite3-dev valgrind
+          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
-        
+
       - name: Build v
         run: make
-        
+
       - 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 -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  /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
-          wine v_from_vc.exe version
-          
+          wine64 ./v_from_vc.exe version
+
       - name: hello_world.v can be cross compiled to hello_world.exe
         run: |
           ./v -os windows examples/hello_world.v
           ls -lart examples/hello_world.exe
-          wine examples/hello_world.exe
-          
+          wine64 examples/hello_world.exe
+
       - name: 2048.v can be cross compiled to 2048.exe
         run: |
           ./v -os windows examples/2048/2048.v
@@ -88,19 +93,19 @@ jobs:
 
   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
       - name: Build
         run: |
           echo %VFLAGS%
           echo $VFLAGS
-          .\make.bat --verbose -msvc
+          .\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/ci_sanitized.yml

@@ -1,24 +1,83 @@
 name: Sanitized CI
 
+## Running these jobs is slow (over ~1 hour, sometimes even 2)
+## so we run them only when there is a chance that the generated
+## C code could have changed, or for some critical vlib modules,
+## like `builtin`, `os`, `sync`, where they have demonstrated
+## their usefulness by catching actual very hard to find bugs.
+## The cost of this selective running is delayed feedback when
+## there are bugs in other V modules.
+## The positive is *much faster CI runs* for most V contributors,
+## that make PRs that are not concerning V itself, or the critical
+## V modules.
+
 on:
   push:
-    paths-ignore:
-      - "**.md"
+    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'
+      - '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/embed_file/**.v'
   pull_request:
-    paths-ignore:
-      - "**.md"
+    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'
+      - '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/embed_file/**.v'
+
+concurrency:
+  group: build-sanitized-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
 
 jobs:
-  no-scheduling:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Dont schedule all jobs
-        run: sleep 10
-
   tests-sanitize-undefined-clang:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
       VFLAGS: -cc clang
       VJOBS: 1
@@ -35,16 +94,18 @@ 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)
         run: ./v2 build-examples
 
   tests-sanitize-undefined-gcc:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
       VFLAGS: -cc gcc
       VJOBS: 1
@@ -60,16 +121,18 @@ jobs:
           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)
         run: ./v2 build-examples
 
   tests-sanitize-address-clang:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
       VFLAGS: -cc clang
       VJOBS: 1
@@ -86,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)
@@ -97,9 +162,9 @@ jobs:
         run: ASAN_OPTIONS=detect_leaks=0 ./v build-examples
 
   tests-sanitize-address-msvc:
-    needs: no-scheduling
     runs-on: windows-2019
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
       VFLAGS: -cc msvc
       VJOBS: 1
@@ -114,19 +179,24 @@ jobs:
           echo %VFLAGS%
           echo $VFLAGS
           .\make.bat -msvc
-          .\v.exe -cflags /WX self
-      - name: Install dependencies
+          .\v.exe self
+      - name: Ensure code is well formatted
         run: |
-          .\v.exe setup-freetype
-          .\.github\workflows\windows-install-sqlite.bat
-      - name: Self tests (-fsanitize=address)
-        run: |
-          .\v.exe -cflags -fsanitize=address test-self
+          .\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
+      ##          .\.github\workflows\windows-install-sqlite.bat
+      ##      - name: Self tests (TODO: /fsanitize=address)
+      ##        run: |
+      ##          .\v.exe -cflags "/fsanitize=address" test-self
 
   tests-sanitize-address-gcc:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
       VFLAGS: -cc gcc
       VJOBS: 1
@@ -143,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)
@@ -154,11 +226,11 @@ jobs:
         run: ASAN_OPTIONS=detect_leaks=0 ./v build-examples
 
   tests-sanitize-memory-clang:
-    needs: no-scheduling
     runs-on: ubuntu-20.04
-    timeout-minutes: 120
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    timeout-minutes: 180
     env:
-      VFLAGS: -cc clang
+      VFLAGS: -cc clang -gc none
       VJOBS: 1
       VTEST_SHOW_START: 1
     steps:
@@ -173,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/ci_v_benchmark.yml

@@ -0,0 +1,36 @@
+name: vlang benchmarks
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  run:
+    name: Run
+    runs-on: ubuntu-latest
+    if: github.event_name != 'push' || github.event.ref == 'refs/heads/master' || github.event.repository.full_name != 'vlang/v'
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Install google benchmark
+      run: |
+          git clone https://github.com/google/benchmark.git
+          cd benchmark
+          cmake -E make_directory "build"
+          cmake -E chdir "build" cmake -DBENCHMARK_DOWNLOAD_DEPENDENCIES=on -DCMAKE_BUILD_TYPE=Release ../
+          sudo cmake --build "build" --config Release --target install
+    - name: Run V benchmark
+      run: |
+        make
+        sudo ./v symlink
+        git clone https://github.com/vincenzopalazzo/benchmarks.git
+        cd benchmarks
+        make vdep && make v
+    - uses: actions/upload-artifact@v3
+      with:
+        name: vlang-benchmark
+        path: benchmarks/vlang/*.json

.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@v2
+
+      - 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@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: All code is formatted
+        run: ./v test-cleancode
+
+      - name: Test V fixed tests
+        run: ./v test-self

.github/workflows/debug_ci.yml

@@ -6,7 +6,7 @@ jobs:
 
   debug-msvc:
     runs-on: windows-2019
-    timeout-minutes: 60
+    timeout-minutes: 121
     env:
       VFLAGS: -cc msvc
     steps:
@@ -18,23 +18,24 @@ jobs:
         run: |
           echo %VFLAGS%
           echo $VFLAGS
-          .\make.bat --verbose -msvc
+          .\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
+        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,8 +1,16 @@
 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:
@@ -14,5 +22,26 @@ jobs:
         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@v2
+      - name: Build V
+        run: make
+
+      - name: Checkout previous v
+        uses: actions/checkout@v2
+        with:
+          repository: vlang/v
+          ref: master   # important
+          path: pv
+
+      - name: Check against parent commit
+        run: |
+          ./v missdoc --diff $MOPTIONS pv/vlib vlib

.github/workflows/freebsd_build_tcc.sh

@@ -0,0 +1,33 @@
+#!/usr/local/bin/bash
+
+## should be run in V's main repo folder!
+
+rm -rf tinycc/
+rm -rf thirdparty/tcc/
+
+pushd .
+
+git clone git://repo.or.cz/tinycc.git
+cd tinycc
+
+export CC=clang
+
+./configure \
+            --cc=clang \
+            --prefix=thirdparty/tcc \
+            --bindir=thirdparty/tcc \
+            --crtprefix=thirdparty/tcc/lib:/usr/lib \
+            --libpaths=thirdparty/tcc/lib:/usr/lib:/lib:/usr/local/lib \
+            --debug
+gmake
+gmake install
+
+popd
+
+mv tinycc/thirdparty/tcc thirdparty/tcc
+mv thirdparty/tcc/tcc thirdparty/tcc/tcc.exe
+
+sudo ln -s $(pwd)/thirdparty/tcc/tcc.exe /usr/local/bin/tcc
+
+thirdparty/tcc/tcc.exe -v -v
+

.github/workflows/gen_vc.yml

@@ -10,6 +10,7 @@ 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:
@@ -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

@@ -0,0 +1,54 @@
+name: Graphics CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  gg-regressions:
+    runs-on: ubuntu-latest
+    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
+    steps:
+      - name: Checkout V
+        uses: actions/checkout@v2
+
+      - name: Build local v
+        run: make
+
+      - name: Setup dependencies
+        run: |
+          # imagemagick              : convert, mogrify
+          # xvfb                     : xvfb
+          # openimageio-tools        : idiff
+          # libxcursor-dev libxi-dev : V gfx deps
+          # libgl1-mesa-dri          : For headless rendering / software DRI driver (LIBGL_ALWAYS_SOFTWARE=true)
+          # freeglut3-dev            : Fixes graphic apps compilation with tcc
+          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
+
+      - name: Sample and compare
+        id: compare
+        continue-on-error: true
+        run: |
+          Xvfb $DISPLAY -screen 0 1280x1024x24 &
+          sleep 1 # give xvfb time to start
+          ./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/native_backend_tests.yml

@@ -0,0 +1,81 @@
+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/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/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-18.04, ubuntu-20.04,
+          macos-11, macos-12,
+          windows-2019, windows-2022
+        ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - 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

@@ -0,0 +1,153 @@
+name: Other CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+concurrency:
+  group: build-other-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+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
+      - 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
+      - name: Environment info
+        run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
+      - name: Build local v
+        run: make -j4
+      - name: v test-cleancode
+        run: ./v test-cleancode
+      - name: v 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
+      - name: Environment info
+        run: echo $VFLAGS $GITHUB_SHA $GITHUB_REF
+      - name: Build local v
+        run: make -j4
+      - name: Clone & Build previous vmaster/v
+        run: |
+          git clone --depth=1 https://github.com/vlang/v vmaster/
+          (cd vmaster; make -j4)
+      - name: V versions
+        run: ./v version && ./vmaster/v version
+      - name: Build the repeat tool
+        run: ./v cmd/tools/repeat.v
+      - 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
+
+  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
+        with:
+          fetch-depth: 10
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          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
+
+      - name: Build v
+        run: make
+
+      - 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 test-self
+
+      - 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
+
+      - name: Shader examples can be build
+        run: |
+          wget https://github.com/floooh/sokol-tools-bin/raw/33d2e4cc26088c6c28eaef5467990f8940d15aab/bin/linux/sokol-shdc
+          chmod +x ./sokol-shdc
+          for f in examples/sokol/02_cubes_glsl/cube_glsl \
+              examples/sokol/03_march_tracing_glsl/rt_glsl \
+              examples/sokol/04_multi_shader_glsl/rt_glsl_puppy \
+              examples/sokol/04_multi_shader_glsl/rt_glsl_march \
+              examples/sokol/05_instancing_glsl/rt_glsl_instancing \
+              examples/sokol/06_obj_viewer/gouraud \
+              ; do \
+                 echo "compiling shader $f.glsl ..."; \
+                 ./sokol-shdc --input $f.glsl --output $f.h --slang glsl330 ; \
+          done
+          ./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
+      - name: Install zzuf
+        run: sudo apt install -qq zzuf
+      - name: Build local v
+        run: |
+          make -j4
+          ./v -g cmd/tools/vtest-parser.v
+      - name: Run test-parser
+        run: |
+          ./v test-parser -S examples/hello_world.v
+          ./v test-parser -S examples/hanoi.v
+          ./v test-parser -S examples/fibonacci.v
+          ./v test-parser -S examples/cli.v
+          ./v test-parser -S examples/json.v
+          ./v test-parser -S examples/vmod.v
+          ./v test-parser -S examples/regex/regex_example.v
+          ./v test-parser -S examples/2048/2048.v
+
+      - name: Run test-parser over fuzzed files
+        run: |
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/hello_world.v > examples/hello_world_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/hanoi.v > examples/hanoi_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/fibonacci.v > examples/fibonacci_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/cli.v > examples/cli_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/json.v > examples/json_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/vmod.v > examples/vmod_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/regex/regex_example.v > examples/regex_example_fuzz.v
+          zzuf -R '\x00-\x20\x7f-\xff' -r0.01 < examples/2048/2048.v > examples/2048/2048_fuzz.v
+          ./v test-parser -S examples/hello_world_fuzz.v
+          ./v test-parser -S examples/hanoi_fuzz.v
+          ./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
+

.github/workflows/paths_ci.yml

@@ -0,0 +1,107 @@
+name: Path Testing CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+concurrency:
+  group: build-paths-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+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
+        with:
+          path: ${{env.MY_V_PATH}}
+      - name: Build V
+        run: |
+          echo '${{env.MY_V_PATH}}'
+          ls -la
+          cd '${{env.MY_V_PATH}}'
+          ls -la
+          make
+      - name: v doctor
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v doctor
+      - name: v tests
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v test vlib/builtin vlib/os
+
+  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
+        with:
+          path: ${{env.MY_V_PATH}}
+      - name: Build V
+        run: |
+          echo '${{env.MY_V_PATH}}'
+          ls -la
+          cd '${{env.MY_V_PATH}}'
+          ls -la
+          make
+          ## prebuild cmd/tools/builders/js_builder, to minimise the
+          ## chances of a sporadic "Killed" when running the tests later
+          ./v -b js run examples/hello_world.v
+      - name: v doctor
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v doctor
+      - name: v tests
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v test vlib/builtin vlib/os
+
+  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'
+
+      ## NB: the following paths do not work for now:
+      ##### MY_V_PATH: '你好 my $path, @с интервали'
+      ##### MY_V_PATH: 'path with some $punctuation, and some spaces '
+      ## tcc has a problem interpreting paths with non latin letters in them,
+      ## by default, but that can be solved with passing -Bthirdparty/tcc
+      ## but after that V fails self building with:
+      ####### builder error: cannot write to folder
+      ####### D:\a\v\v\你好 my $path, @с интервали: No such file or directory
+      ## and that happens even for gcc builds, not just tcc ones
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          path: ${{env.MY_V_PATH}}
+      - name: Build V
+        run: |
+          echo '${{env.MY_V_PATH}}'
+          dir
+          cd '${{env.MY_V_PATH}}'
+          dir
+          .\make.bat -tcc
+      - name: v doctor
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v doctor
+      - name: v tests
+        run: |
+          cd '${{env.MY_V_PATH}}'
+          ./v test vlib/builtin vlib/os

.github/workflows/periodic.yml

@@ -2,57 +2,59 @@ name: Periodic
 
 on:
   schedule:
-    - cron:  '0 */2 * * *'
+    - 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
+      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
+      - uses: actions/checkout@v2
+      - 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
+      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
-
+      - 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
+      - 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
+      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
+      - 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/sdl_ci.yml

@@ -0,0 +1,51 @@
+name: sdl CI
+
+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
+    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
+      - name: Build V
+        run: make && sudo ./v symlink
+
+      - name: Clone sdl into .vmodules
+        run: |
+          git clone --depth 1 https://github.com/vlang/sdl
+          cd sdl
+          mkdir -p ~/.vmodules
+          ln -s $(pwd) ~/.vmodules/sdl
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y libsdl2-dev libsdl2-ttf-dev
+          sudo apt-get install --quiet -y libsdl2-mixer-dev libsdl2-image-dev
+
+      - name: Run tests
+        run: ./v test sdl
+
+      - name: Build sdl shared
+        run: ./v -shared -g sdl
+
+      - name: Build sdl examples
+        run: |
+          v shader sdl/examples/sdl_opengl_and_sokol
+          v should-compile-all sdl/examples/

.github/workflows/toml_ci.yml

@@ -0,0 +1,73 @@
+name: toml CI
+
+on:
+  push:
+    paths-ignore:
+      - "**.md"
+  pull_request:
+    paths-ignore:
+      - "**.md"
+
+jobs:
+  toml-module-pass-external-test-suites:
+    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
+      TOML_BS_TESTS_PINNED_COMMIT: 4634fdf
+      TOML_IARNA_TESTS_PATH: vlib/toml/tests/testdata/iarna/toml-test
+      TOML_IARNA_TESTS_PINNED_COMMIT: 1880b1a
+      TOML_AC_TESTS_PATH: vlib/toml/tests/testdata/alexcrichton/toml-test
+      TOML_AC_TESTS_PINNED_COMMIT: 499e8c4
+      VTEST_TOML_DO_LARGE_FILES: 1
+      VTEST_TOML_DO_YAML_CONVERSION: 1
+    steps:
+
+      - uses: actions/checkout@v2
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --quiet -y jq libgc-dev
+      - name: Build V
+        run: make -j2 && ./v -cc gcc -o v cmd/v
+
+      - name: Show JQ Version
+        run: jq --version
+
+      - name: Run local TOML tests
+        run: ./v test vlib/toml
+
+        # Tests found at https://github.com/BurntSushi/toml-test
+      - name: Clone BurntSushi/toml-test
+        run: |
+          git clone -n https://github.com/BurntSushi/toml-test.git $TOML_BS_TESTS_PATH
+          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
+
+        # Tests found at gist
+      - name: Get large_toml_file_test.toml
+        run: wget https://gist.githubusercontent.com/Larpon/89b0e3d94c6903851ff15559e5df7a05/raw/62a1f87a4e37bf157f2e0bfb32d85d840c98e422/large_toml_file_test.toml -O vlib/toml/tests/testdata/large_toml_file_test.toml
+
+      - name: Run large TOML file tests
+        run: ./v vlib/toml/tests/large_toml_file_test.v
+
+        # Tests found at https://github.com/iarna/toml-spec-tests
+      - name: Clone iarna/toml-spec-tests
+        run: |
+          git clone -n https://github.com/iarna/toml-spec-tests.git $TOML_IARNA_TESTS_PATH
+          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
+
+        # Tests found at https://github.com/alexcrichton/toml-rs
+      - name: Clone alexcrichton/toml-rs
+        run: |
+          git clone -n https://github.com/alexcrichton/toml-rs.git $TOML_AC_TESTS_PATH
+          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

.github/workflows/v_apps_and_modules_compile.yml

@@ -0,0 +1,142 @@
+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@v2
+      - 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
+
+      - name: Build V Language Server (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 V 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 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 Gitly
+        run: |
+          echo "Install markdown"
+          v install markdown
+          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 libsodium
+        run: |
+          echo "Install the libsodium wrapper"
+          v install libsodium
+          echo "Test libsodium"
+          VJOBS=1 v test ~/.vmodules/libsodium
+
+      - 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
+
+      - name: Build 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: Build vlang/pdf
+        run: |
+          v install pdf
+          echo "PDF examples should compile"
+          v should-compile-all ~/.vmodules/pdf/examples
+
+      - name: Install UI through VPM
+        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 VSL
+        run: |
+          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 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

.github/workflows/vab_ci.yml

@@ -11,7 +11,10 @@ on:
 jobs:
   vab-compiles-v-examples:
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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
     steps:
     - uses: actions/setup-java@v2
       with:
@@ -20,33 +23,52 @@ jobs:
 
     - uses: actions/checkout@v2
     - name: Build V
-      run: make -j2 && ./v -cc gcc -o v cmd/v
+      run: make && sudo ./v symlink
 
-    - name: Clone vab
-      run: git clone --depth 1 https://github.com/vlang/vab
-    - name: Build vab
-      run: cd vab; ../v ./vab.v ; cd ..
+    - name: Install vab
+      run: |
+        v install vab
+        v -g ~/.vmodules/vab
+        sudo ln -s ~/.vmodules/vab/vab /usr/local/bin/vab
 
     - name: Run tests
-      run: ./v test vab
-
-    - name: Build vab
-      run: ./v -g vab/vab.v
+      run: v test ~/.vmodules/vab
 
     - name: Run vab --help
-      run: vab/vab --help
+      run: vab --help
 
     - name: Run vab doctor
-      run: |
-        export VEXE=./v
-        vab/vab doctor
+      run: vab doctor
 
     - name: Build graphical V examples as APK
       run: |
         declare -a v_examples=('flappylearning' '2048' 'fireworks' 'tetris' 'sokol/particles' 'sokol/drawing.v' 'sokol/freetype_raven.v' 'gg/polygons.v' 'gg/raven_text_rendering.v' 'gg/rectangles.v' 'gg/stars.v' 'gg/worker_thread.v')
         mkdir apks
-        export VEXE=./v
         for example in "${v_examples[@]}"; do
           safe_name=$(echo "$example" | sed 's%/%-%' | sed 's%\.%-%' )
-          vab/vab --api 29 --build-tools '29.0.0' -v 3 examples/$example -o apks/$safe_name.apk
+          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@v2
+    - 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

@@ -2,28 +2,36 @@ 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@v2
+
       - name: Install dependencies
-        run: sudo apt-get update && sudo apt-get install build-essential meson -y
+        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 -p3 < ../vinix/patches/mlibc/mlibc.patch
-      - 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
+        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 -I../../mlibc-headers/include" V="../../v" && make clean
+        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 -I../../mlibc-headers/include" V="../../v" && make clean
+        run: cd vinix/kernel && make PROD=true CFLAGS="-D__vinix__ -O2 -g -pipe" V="../../v" && make clean

.github/workflows/websockets.yml

@@ -11,7 +11,8 @@ on:
 jobs:
   websocket_tests:
     runs-on: ubuntu-20.04
-    timeout-minutes: 60
+    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:

.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
-

.gitignore

@@ -20,6 +20,7 @@ vdbg.exe
 *.dll
 *.lib
 *.bak
+*.dylib
 a.out
 .noprefix.vrepl_temp
 
@@ -30,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
@@ -49,12 +54,14 @@ fns.txt
 !Dockerfile.cross
 !LICENSE
 !Makefile
+!GNUmakefile
 
 # ignore editor files
 .idea
 .project
 .classpath
 .c9
+.vs
 *.launch
 .settings/
 *.sublime-workspace
@@ -71,6 +78,7 @@ cachegrind.out.*
 .gdb_history
 *.dSYM
 *.def
+vgcore.*
 
 # ignore system files
 .DS_Store
@@ -98,3 +106,14 @@ shell.nix
 default.nix
 flake.nix
 .envrc
+
+thirdparty/stdatomic/nix/cpp/*.h
+
+# ignore VLS log
+vls.log
+
+# ignore v2go tmperror files
+*.tmperr
+
+*/**/tmp.*
+

BSDmakefile

@@ -1,8 +0,0 @@
-CC ?= cc
-
-all:
-	rm -rf vc/
-	git clone --depth 1 --quiet https://github.com/vlang/vc
-	$(CC) -std=gnu11 -w -o v vc/v.c -lm -lexecinfo
-	rm -rf vc/
-	@echo "V has been successfully built"

CHANGELOG.md

@@ -1,10 +1,157 @@
--## V 0.2.4
--*Not yet released, changelog is not full*
+## V 0.3.2
+*Not yet released*
+- New stunnig playground with an improved look and feel, much better and responsive editor,
+  code sharing by link, more convenient keyboard control, reusability for potential embedding:
+  https://play.vlang.io.
+- msgpack module for decoding/encoding msgpack.
+- Easier custom error creation: `return MyCustomErr{}` instead of `return IError(MyCustomErr)`.
+- Remove the need for the `[console]` attribute in Windows GUI apps.
+- All floats outputs now have `.0` conditionally appended to them to improve clarity.
+
+
+## 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 optionals: `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 arithmetics 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.
-- Bare metal support. Vinix OS kernel is now being developed in V.
+*... lots of missing changelog for this version, sorry (will update a bit later)*
 
 ## V 0.2.2 - 0.2.3
 *22 Jan 2021*
@@ -44,12 +191,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.

CONTRIBUTING.md

@@ -35,32 +35,35 @@ The main files are:
 - 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
+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
+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.
+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
+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
+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
+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
+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. `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.
 
-9. `v/gen/native` is the directory with all the machine code generation logic. It
+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
@@ -90,6 +93,7 @@ making pullrequests, and you can just do normal git operations such as:
 
 5. When finished with a feature/bugfix/change, you can:
 `git checkout -b fix_alabala`
+   - 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
 
@@ -183,17 +187,20 @@ to create a copy of the compiler rather than replacing it with `v self`.
 
 | Flag | Usage |
 |------|-------|
-| `debugautostr` | Prints informations about `.str()` method auto-generated by the compiler during C generation |
 | `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 informations |
-| `time_parsing` | Prints the time spent parsing files and other related informations |
+| `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 informations about the statements being checked |
+| `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 informations about parsed statements and expressions |
-| `trace_thirdparty_obj_files` | Prints informations about built thirdparty obj files |
-| `trace_use_cache` | Prints informations about cache use |
+| `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,6 +1,6 @@
 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

GNUmakefile

@@ -0,0 +1,205 @@
+CC ?= cc
+CFLAGS ?=
+LDFLAGS ?=
+TMPDIR ?= /tmp
+VROOT  ?= .
+VC     ?= ./vc
+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
+
+#### Platform detections and overrides:
+_SYS := $(shell uname 2>/dev/null || echo Unknown)
+_SYS := $(patsubst MSYS%,MSYS,$(_SYS))
+_SYS := $(patsubst MINGW%,MinGW,$(_SYS))
+
+ifneq ($(filter $(_SYS),MSYS MinGW),)
+WIN32 := 1
+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)
+TCCOS := freebsd
+LDFLAGS += -lexecinfo
+endif
+
+ifeq ($(_SYS),NetBSD)
+TCCOS := netbsd
+LDFLAGS += -lexecinfo
+endif
+
+ifdef ANDROID_ROOT
+ANDROID := 1
+undefine LINUX
+TCCOS := android
+endif
+#####
+
+ifdef WIN32
+TCCOS := windows
+VCFILE := v_win.c
+endif
+
+TCCARCH := $(shell uname -m 2>/dev/null || echo unknown)
+
+ifeq ($(TCCARCH),x86_64)
+	TCCARCH := amd64
+else
+ifneq ($(filter x86%,$(TCCARCH)),)
+	TCCARCH := i386
+else
+ifeq ($(TCCARCH),arm64)
+	TCCARCH := arm64
+else
+ifneq ($(filter arm%,$(TCCARCH)),)
+	TCCARCH := arm
+# otherwise, just use the arch name
+endif
+endif
+endif
+endif
+
+.PHONY: all clean check fresh_vc fresh_tcc fresh_legacy check_for_working_tcc
+
+ifdef prod
+VFLAGS+=-prod
+endif
+
+all: latest_vc latest_tcc latest_legacy
+ifdef WIN32
+	$(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 $(VEXE) $(VFLAGS) cmd/v
+	del v1.exe
+	del v2.exe
+else
+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 $(VEXE) $(VFLAGS) cmd/v
+	rm -rf v1.exe v2.exe
+endif
+	@$(VEXE) run cmd/tools/detect_tcc.v
+	@echo "V has been successfully built"
+	@$(VEXE) -version
+
+clean:
+	rm -rf $(TMPTCC)
+	rm -rf $(LEGACYLIBS)
+	rm -rf $(VC)
+
+ifndef local
+latest_vc: $(VC)/.git/config
+	cd $(VC) && $(GITCLEANPULL)
+else
+latest_vc:
+	@echo "Using local vc"
+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)
+
+ifndef local
+latest_tcc: $(TMPTCC)/.git/config
+	cd $(TMPTCC) && $(GITCLEANPULL)
+	@$(MAKE) --quiet check_for_working_tcc 2> /dev/null
+else
+latest_tcc:
+	@echo "Using local tcc"
+	@$(MAKE) --quiet check_for_working_tcc 2> /dev/null
+endif
+
+fresh_tcc:
+	rm -rf $(TMPTCC)
+ifndef local
+# Check wether a TCC branch exists for the user's system configuration.
+ifneq (,$(findstring thirdparty-$(TCCOS)-$(TCCARCH), $(shell git ls-remote --heads $(TCCREPO) | sed 's/^[a-z0-9]*\trefs.heads.//')))
+	$(GITFASTCLONE) --branch thirdparty-$(TCCOS)-$(TCCARCH) $(TCCREPO) $(TMPTCC)
+	@$(MAKE) --quiet check_for_working_tcc 2> /dev/null
+else
+	@echo 'Pre-built TCC not available for thirdparty-$(TCCOS)-$(TCCARCH) at $(TCCREPO), will use the system compiler: $(CC)'
+	$(GITFASTCLONE) --branch thirdparty-unknown-unknown $(TCCREPO) $(TMPTCC)
+	@$(MAKE) --quiet check_for_working_tcc 2> /dev/null
+endif
+else
+	@echo "Using local tccbin"
+	@$(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:
+	$(VEXE) -cg -o v cmd/v
+
+selfcompile-static:
+	$(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

Makefile

@@ -1,154 +1,19 @@
 CC ?= cc
+VFLAGS ?=
 CFLAGS ?=
 LDFLAGS ?=
-TMPDIR ?= /tmp
-VROOT  ?= .
-VC     ?= ./vc
-V      ?= ./v
-VCREPO ?= https://github.com/vlang/vc
-TCCREPO ?= https://github.com/vlang/tccbin
 
-VCFILE := v.c
-TMPTCC := $(VROOT)/thirdparty/tcc
-TCCOS := unknown
-TCCARCH := unknown
-GITCLEANPULL := git clean -xf && git pull --quiet
-GITFASTCLONE := git clone --depth 1 --quiet --single-branch
+.PHONY: all check
 
-#### Platform detections and overrides:
-_SYS := $(shell uname 2>/dev/null || echo Unknown)
-_SYS := $(patsubst MSYS%,MSYS,$(_SYS))
-_SYS := $(patsubst MINGW%,MinGW,$(_SYS))
-
-ifneq ($(filter $(_SYS),MSYS MinGW),)
-WIN32 := 1
-V:=./v.exe
-endif
-
-ifeq ($(_SYS),Linux)
-LINUX := 1
-TCCOS := linux
-endif
-
-ifeq ($(_SYS),Darwin)
-MAC := 1
-TCCOS := macos
-endif
-
-ifeq ($(_SYS),FreeBSD)
-TCCOS := freebsd
-LDFLAGS += -lexecinfo
-endif
-
-ifeq ($(_SYS),NetBSD)
-TCCOS := netbsd
-LDFLAGS += -lexecinfo
-endif
-
-ifdef ANDROID_ROOT
-ANDROID := 1
-undefine LINUX
-TCCOS := android
-endif
-#####
-
-ifdef WIN32
-TCCOS := windows
-VCFILE := v_win.c
-endif
-
-TCCARCH := $(shell uname -m 2>/dev/null || echo unknown)
-
-ifeq ($(TCCARCH),x86_64)
-	TCCARCH := amd64
-else
-ifneq ($(filter x86%,$(TCCARCH)),)
-	TCCARCH := i386
-else
-ifeq ($(TCCARCH),arm64)
-	TCCARCH := arm64
-else
-ifneq ($(filter arm%,$(TCCARCH)),)
-	TCCARCH := arm
-# otherwise, just use the arch name
-endif
-endif
-endif
-endif
-
-.PHONY: all clean fresh_vc fresh_tcc
-
-ifdef prod
-VFLAGS+=-prod
-endif
-
-all: latest_vc latest_tcc
-ifdef WIN32
-	$(CC) $(CFLAGS) -std=c99 -municode -w -o $(V) $(VC)/$(VCFILE) $(LDFLAGS)
-	$(V) -o v2.exe $(VFLAGS) cmd/v
-	move /y v2.exe v.exe
-else
-	$(CC) $(CFLAGS) -std=gnu99 -w -o $(V) $(VC)/$(VCFILE) -lm -lpthread $(LDFLAGS)
-	$(V) -o v2.exe $(VFLAGS) cmd/v
-	mv -f v2.exe v  
-endif
+all:
+	rm -rf vc/
+	git clone --depth 1 --quiet https://github.com/vlang/vc
+	$(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/
 	@echo "V has been successfully built"
-	@$(V) -version
+	./v run ./cmd/tools/detect_tcc.v
 
-clean:
-	rm -rf $(TMPTCC)
-	rm -rf $(VC)
-
-ifndef local
-latest_vc: $(VC)/.git/config
-	cd $(VC) && $(GITCLEANPULL)
-else
-latest_vc:
-	@echo "Using local vc"
-endif
-
-fresh_vc:
-	rm -rf $(VC)
-	$(GITFASTCLONE) $(VCREPO) $(VC)
-
-ifndef local
-latest_tcc: $(TMPTCC)/.git/config
-	cd $(TMPTCC) && $(GITCLEANPULL)
-else
-latest_tcc:
-	@echo "Using local tcc"
-endif
-
-fresh_tcc:
-	rm -rf $(TMPTCC)
-ifndef local
-# Check wether a TCC branch exists for the user's system configuration.
-ifneq (,$(findstring thirdparty-$(TCCOS)-$(TCCARCH), $(shell git ls-remote --heads $(TCCREPO) | sed 's/^[a-z0-9]*\trefs.heads.//')))
-	$(GITFASTCLONE) --branch thirdparty-$(TCCOS)-$(TCCARCH) $(TCCREPO) $(TMPTCC)
-else
-	@echo 'Pre-built TCC not available for thirdparty-$(TCCOS)-$(TCCARCH) at $(TCCREPO), will use the system compiler: $(CC)'
-	$(GITFASTCLONE) --branch thirdparty-unknown-unknown $(TCCREPO) $(TMPTCC)
-endif
-else
-	@echo "Using local tccbin"
-endif
-
-$(TMPTCC)/.git/config:
-	$(MAKE) fresh_tcc
-
-$(VC)/.git/config:
-	$(MAKE) fresh_vc
-
-asan:
-	$(MAKE) all CFLAGS='-fsanitize=address,undefined'
-
-selfcompile:
-	$(V) -cg -o v cmd/v
-
-selfcompile-static:
-	$(V) -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:
+	./v test-all

README.md

@@ -1,14 +1,10 @@
 <div align="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"></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">
@@ -25,22 +21,23 @@
 
 ## Key Features of V
 
-- Simplicity: the language can be learned in less than an hour
+- Simplicity: the language can be learned in 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)
+- 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
+- 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))
 - [Cross-platform UI library](https://github.com/vlang/ui)
 - Built-in graphics library
-- Easy cross compilation
+- Easy cross-compilation
 - REPL
 - [Built-in ORM](https://github.com/vlang/v/blob/master/doc/docs.md#orm)
 - [Built-in web framework](https://github.com/vlang/v/blob/master/vlib/vweb/README.md)
 - C and JavaScript backends
+- Great for writing low-level software ([Vinix OS](https://github.com/vlang/vinix))
 
 ## Stability guarantee and future changes
 
@@ -59,23 +56,40 @@ Unlike many other languages, V is not going to be always changing, with new feat
 being introduced and old features modified. It is always going to be a small and simple
 language, very similar to the way it is right now.
 
-## Installing V from source
+## Installing V - from source *(preferred method)*
 
-### Linux, macOS, Windows, *BSD, Solaris, WSL, Android, Raspbian
+### Linux, macOS, Windows, *BSD, Solaris, WSL, Android, etc.
 
+Usually installing V is quite simple if you have an environment that already has a
+functional `git` installation.
+
+* *(* ***PLEASE 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.)*
+
+
+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 the cmd.exe shell
 ```
 
-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`, so make sure you use
+the `cmd.exe` terminal.)
 
 Now you can try `./v run examples/hello_world.v` (`v.exe` on Windows).
 
+* *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:
 
 ```bash
@@ -111,7 +125,7 @@ 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
+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:
 
@@ -124,7 +138,7 @@ Please restart your shell/editor after that, so that it can pick
 the new PATH variable.
 
 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.
+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.
 
@@ -150,7 +164,7 @@ docker run --rm -it vlang:latest
 
 </details>
 
-### Testing and running the examples
+## Testing and running the examples
 
 Make sure V can compile itself:
 
@@ -160,7 +174,7 @@ v self
 
 ```bash
 $ v
-V 0.2.x
+V 0.3.x
 Use Ctrl-C or `exit` to exit
 
 >>> println('hello world')
@@ -183,7 +197,9 @@ v run tetris/tetris.v
 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` .
 
-If you plan to use the http package, you also need to install OpenSSL on non-Windows systems.
+## 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:
@@ -263,6 +279,20 @@ https://github.com/vlang/gitly
 
 <img src="https://user-images.githubusercontent.com/687996/85933714-b195fe80-b8da-11ea-9ddd-09cadc2103e4.png">
 
+## Vinix, an OS/kernel written in V
+
+V is great for writing low-level software like drivers and kernels.
+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/blob/main/screenshot0.png?raw=true">
+<img src="https://github.com/vlang/vinix/blob/main/screenshot1.png?raw=true">
+
+## 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)

ROADMAP.md

@@ -1,32 +1,17 @@
-## [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)
-- [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
-- [ ] parallel cgen
+## [Version 0.4]
+- [ ] [Coroutines](https://github.com/vlang/v/discussions/11582)
+- [ ] [Thread safe maps](https://github.com/vlang/v/discussions/11729)
+- [ ] Parallel parser
+- [ ] Parallel checker
+- [ ] Parallel C compilation
 - [ ] `recover()` from panics
-- [x] IO streams
-- [x] struct embedding
-- [ ] 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
+- [ ] vfmt: add missing imports (like goimports)
 - [ ] Recursive structs via optionals: `struct Node { next ?Node }`
-- [ ] Remove `foo = 0` for `&Foo`
+- [ ] Optional function struct fields
+- [ ] Handle function pointers safely, remove `if function == 0 {`
+- [x] Bundle OpenSSL like GC
+- [x] Anonymous structs
+- [ ] -usecache on by default
+- [ ] -skip-unused on by default
+- [ ] `any` type
+- [ ] `copy()` builtin function (e.g. for easier conversion from `[]Foo` to `[4]Foo`)

TESTS.md

@@ -1,93 +1,12 @@
 # Automated tests
 
-TLDR: run `v test-all` locally, after making your changes,
+TLDR: do run `v test-all` locally, after making your changes,
 and before submitting PRs.
 
-## Notes
-In the `v` repo there are several different tests. The main types are:
-
-* `_test.v` tests - check that `test_` functions succeed. These can be
-run per directory or individually.
-* `.out` tests - run a `.vv` file and check the output matches the
-contents of the `.out` file with the same base name. This is
-particularly useful for checking that errors are printed.
-
-Tip: use `v -cc tcc` when compiling tests for speed.
-
-## `vlib/v/tests`
-
-General runnable tests for different features of the V compiler.
-
-* `vlib/v/tests/inout/compiler_test.v`
-
-Test output of running a V program matches an expected .out file.
-Check the source for how to test panics.
-
-* `vlib/v/tests/run_project_folders_test.v`
-Tests whether whole project folders can be compiled, and run.
-NB: Each project in these folders, should finish with exit code 0,
-and it should output `OK` as its last stdout line.
-
-## Test building of actual V programs (examples, tools, V itself)
-
-* `v build-tools`
-* `v build-examples`
-* `v build-vbinaries`
-
-## vfmt tests
-
-In `vlib/v/fmt/` there are::
-
-* `v vlib/v/fmt/fmt_test.v`
-
-This checks `.out` tests.
-
-* `v vlib/v/fmt/fmt_keep_test.v`
-
-This verifies that `_keep.v` files would be unchanged by `vfmt -w`.
-
-* `v vlib/v/fmt/fmt_vlib_test.v`
-
-This checks all source files are formatted and prints a summary.
-This is not required.
-
-* `v test-fmt`
-
-Test all files in the current directory are formatted.
-
-## Markdown
-
-* `v check-md -hide-warnings .`
-
-Ensure that all .md files in the project are formatted properly,
-and that the V code block examples in them can be compiled/formatted too.
-
-## `.github/workflows/ci.yml`
-
-This runs various CI tests, e.g.:
-
-* `v vet vlib/v` - style checker
-* `v fmt -verify` on certain source files
-
-## `v test-cleancode`
-
-Check that most .v files, are invariant of `v fmt` runs.
-
-## `v test-self`
-
-Run `vlib` module tests, *including* the compiler tests.
-
-## `v vlib/v/compiler_errors_test.v`
-
-This runs tests for:
-* `vlib/v/checker/tests/*.vv`
-* `vlib/v/parser/tests/*.vv`
-
-### Special folders that compiler_errors_test.v will try to
-run/compile with specific options:
-
-vlib/v/checker/tests/globals_run/ - `-enable-globals run`; 
-results stored in `.run.out` files, matching the .vv ones.
+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 
+hundreds/thousands of times.
 
 ## `v test-all`
 
@@ -102,3 +21,157 @@ It works, by running these in succession:
 * `v build-examples`
 * `v check-md -hide-warnings .`
 * `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 
+V's test framework.
+
+NB 1: You can run test files one by one, with:
+`v file_test.v` - this will run the test_ functions in file_test.v,
+and will exit with a 0 exit code, if they all had 0 failing assertions.
+
+`v -stats file_test.v` - this will run the test_ functions, and show a
+report about how much time it took to run each of them too.
+
+NB 2: You can also run many test files at once (in parallel, depending on
+how many cores you have), with:
+`v test folder` - this will run *all* `_test.v` files in `folder`,
+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`
+
+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
+
+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
+for checking that errors and panics are printed.
+
+## `v vlib/v/gen/c/coutput_test.v`
+
+coutput_test.v is a *test runner*, that checks whether the generated C source
+code matches *all* expectations, specified in *.c.must_have files, in the
+folder vlib/v/gen/c/testdata/ .
+
+Each `.c.must_have` file, *has* to have a corresponding `.vv` file.
+
+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`
+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.
+
+## `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)
+
+* `v build-tools`
+* `v build-examples`
+* `v build-vbinaries`
+
+## Formatting tests
+
+In `vlib/v/fmt/` there are:
+
+* `v vlib/v/fmt/fmt_test.v`
+
+This checks `.out` tests.
+
+* `v vlib/v/fmt/fmt_keep_test.v`
+
+This verifies that all `_keep.vv` files in the `vlib/v/fmt/tests/` folder,
+would be unchanged by `v fmt -w`, i.e. that the v source code formatter,
+generates a stable source output, that does not change, once it is already
+formatted once.
+
+* `v vlib/v/fmt/fmt_vlib_test.v`
+
+This checks that all V source files are formatted, and prints a summary.
+This is not required.
+
+* `v test-cleancode`
+
+Check that most .v files, are invariant of `v fmt` runs.
+
+* `v test-fmt`
+
+This tests that all .v files in the current folder are already formatted.
+It is useful for adding to CI jobs, to guarantee, that future contributions
+will keep the existing source nice and clean.
+
+## Markdown/documentation checks:
+
+* `v check-md -hide-warnings .`
+
+Ensure that all .md files in the project are formatted properly,
+and that the V code block examples in them can be compiled/formatted too.
+
+## `v test-self`
+
+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:
+
+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` 
+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 
+commit the new .out files with minimum manual effort.
+
+NB 3: To run only some of the tests, use:
+`VTEST_ONLY=mismatch ./v vlib/v/compiler_errors_test.v`
+This will check only the .vv files, whose paths match the given filter.
+
+## `.github/workflows/ci.yml`
+
+This is a Github Actions configuration file, that runs various CI
+tests in the main V repository, for example:
+
+* `v vet vlib/v` - run a style checker.
+* `v test-self` (run self tests) in various compilation modes.

cmd/tools/bench/wyhash.v

@@ -14,13 +14,13 @@ fn main() {
 	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/c_builder.v

@@ -0,0 +1,11 @@
+module main
+
+import v.builder.cbuilder
+
+// TODO: change bootstrapping to use the C code generated from
+// `VEXE=v cmd/tools/builders/c_builder -os cross -o c.c cmd/tools/builders/c_builder.v`
+// See also `cmd/v/v.v`
+
+fn main() {
+	cbuilder.start()
+}

cmd/tools/builders/golang_builder.v

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

cmd/tools/builders/interpret_builder.v

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

cmd/tools/builders/js_builder.v

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

cmd/tools/builders/native_builder.v

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

cmd/tools/check_os_api_parity.v

@@ -5,6 +5,7 @@ import v.util
 import v.util.diff
 import v.pref
 import v.builder
+import v.builder.cbuilder
 import v.ast
 import rand
 import term
@@ -42,7 +43,7 @@ fn main() {
 	vexe := pref.vexe_path()
 	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
@@ -98,7 +99,7 @@ fn (app App) gen_api_for_module_in_os(mod_name string, os_name string) string {
 	tmpname := '/tmp/${mod_name}_${os_name}.c'
 	prefs, _ := pref.parse_args([], ['-os', os_name, '-o', tmpname, '-shared', mpath])
 	mut b := builder.new_builder(prefs)
-	b.compile_c()
+	cbuilder.compile_c(mut b)
 	mut res := []string{}
 	for f in b.parsed_files {
 		for s in f.stmts {

cmd/tools/detect_tcc.v

@@ -0,0 +1,17 @@
+fn main() {
+	$if tinyc {
+		println('Your `tcc` is working. Good - it is much faster at compiling C source code.')
+		exit(0)
+	}
+
+	$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/fast.v

@@ -1,10 +1,9 @@
-// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2022 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
 
-// TODO -usecache
 const voptions = ' -skip-unused -show-timings -stats '
 
 const exe = os.executable()
@@ -16,66 +15,80 @@ const vdir = @VEXEROOT
 fn main() {
 	dump(fast_dir)
 	dump(vdir)
-	os.chdir(fast_dir)
+	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`')
 	}
 	println('fast.html generator\n')
-	println('Fetching updates...')
-	ret := os.system('$vdir/v up')
-	if ret != 0 {
-		println('failed to update V')
-		return
+	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
+
+	// fetch the last commit's hash
 	commit := exec('git rev-parse HEAD')[..8]
 	if !os.exists('table.html') {
-		os.create('table.html') ?
+		os.create('table.html')!
 	}
-	mut table := os.read_file('table.html') ?
-	if table.contains('>$commit<') {
-		println('nothing to benchmark')
-		exit(1)
-		return
+	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')
+
+	// build an optimized V
 	println('  Building vprod...')
-	os.chdir(vdir)
-	exec('./v -o vprod -prod -prealloc cmd/v')
-	// println('cur vdir="$vdir"')
-	// exec('v -o vprod cmd/v') // for faster debugging
+	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'
+		}
 	}
+	if os.args.contains('-clang') {
+		tcc_path = 'clang'
+	}
+
 	diff2 := measure('$vdir/vprod $voptions -cc $tcc_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',
 		'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
+
+	os.chdir(fast_dir)!
+	mut out := os.create('table.html')!
+
+	// place the new row on top
 	html_message := message.replace_each(['<', '&lt;', '>', '&gt;'])
 	table =
-		'<tr>
+		'	<tr>
 		<td>$date.format()</td>
 		<td><a target=_blank href="https://github.com/vlang/v/commit/$commit">$commit</a></td>
 		<td>$html_message</td>
@@ -92,19 +105,28 @@ fn main() {
 		<td>${int(f64(vlines) / f64(diff1) * 1000.0)}</td>
 	</tr>\n' +
 		table.trim_space()
-	out.writeln(table) ?
+	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) ?
+
+	// 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)!
 	res.close()
-	//}
-	// exec('git checkout master')
-	// os.write_file('last_commit.txt', commits[commits.len - 1]) ?
+
+	// 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')
+	}
 }
 
 fn exec(s string) string {
@@ -112,7 +134,7 @@ fn exec(s string) string {
 	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...')
@@ -164,7 +186,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 }

cmd/tools/fast/fast_job.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2022 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
@@ -23,20 +23,14 @@ fn main() {
 			return
 		}
 		// println('running ./fast')
-		resp := os.execute('./fast')
+		resp := os.execute('./fast -upload')
 		if resp.exit_code < 0 {
 			println(resp.output)
 			return
 		}
 		if resp.exit_code != 0 {
 			println('resp != 0, skipping')
-		} else {
-			os.chdir('website')
-			os.execute_or_exit('git checkout gh-pages')
-			os.cp('../index.html', 'index.html') ?
-			os.system('git commit -am "update benchmark"')
-			os.system('git push origin gh-pages')
-			os.chdir('..')
+			println(resp.output)
 		}
 		time.sleep(180 * time.second)
 	}

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]++

cmd/tools/gen1m.v

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

cmd/tools/gen_vc.v

@@ -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
@@ -169,10 +169,10 @@ pub fn (mut ws WebhookServer) genhook() {
 	ws.gen_vc.generate()
 	// error in generate
 	if ws.gen_vc.gen_error {
-		ws.json('{status: "failed"}')
+		ws.json('{ status: "failed" }')
 		return
 	}
-	ws.json('{status: "ok"}')
+	ws.json('{ status: "ok" }')
 }
 
 pub fn (ws &WebhookServer) reset() {
@@ -215,7 +215,7 @@ fn (mut gen_vc GenVC) generate() {
 		}
 	}
 	// cd to gen_vc dir
-	os.chdir(gen_vc.options.work_dir)
+	os.chdir(gen_vc.options.work_dir) or {}
 	// if we are not running with the --serve flag (webhook server)
 	// rather than deleting and re-downloading the repo each time
 	// first check to see if the local v repo is behind master

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,16 +33,19 @@ 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) {
@@ -85,7 +89,10 @@ fn modfn(mname string, fname string) string {
 
 pub fn chdir(path string) {
 	verbose_trace_strong(modfn(@MOD, @FN), 'cd $path')
-	os.chdir(path)
+	os.chdir(path) or {
+		verbose_trace(modfn(@MOD, @FN), '## failed.')
+		return
+	}
 }
 
 pub fn mkdir(path string) ? {

cmd/tools/modules/testing/common.v

@@ -4,17 +4,40 @@ import os
 import time
 import term
 import benchmark
+import sync
 import sync.pool
 import v.pref
 import v.util.vtest
+import runtime
 
-const github_job = os.getenv('GITHUB_JOB')
+pub const github_job = os.getenv('GITHUB_JOB')
 
-const show_start = os.getenv('VTEST_SHOW_START') == '1'
+pub const show_start = os.getenv('VTEST_SHOW_START') == '1'
 
-const hide_skips = os.getenv('VTEST_HIDE_SKIP') == '1'
+pub const hide_skips = os.getenv('VTEST_HIDE_SKIP') == '1'
 
-const hide_oks = os.getenv('VTEST_HIDE_OK') == '1'
+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 = 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:
@@ -24,7 +47,7 @@ pub mut:
 	vroot         string
 	vtmp_dir      string
 	vargs         string
-	failed        bool
+	fail_fast     bool
 	benchmark     benchmark.Benchmark
 	rm_binaries   bool = true
 	silent_mode   bool
@@ -110,6 +133,7 @@ pub fn (mut ts TestSession) print_messages() {
 			// progress mode, the last line is rewritten many times:
 			if is_ok && !ts.silent_mode {
 				print('\r$empty\r$msg')
+				flush_stdout()
 			} else {
 				// the last \n is needed, so SKIP/FAIL messages
 				// will not get overwritten by the OK ones
@@ -127,7 +151,16 @@ pub fn (mut ts TestSession) print_messages() {
 
 pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 	mut skip_files := []string{}
+
+	// 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'
+
 	if will_compile {
+		$if msvc {
+			skip_files << 'vlib/v/tests/const_comptime_eval_before_vinit_test.v' // _constructor used
+		}
 		$if solaris {
 			skip_files << 'examples/gg/gg2.v'
 			skip_files << 'examples/pico/pico.v'
@@ -142,16 +175,38 @@ 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
+			skip_files << 'examples/sokol/simple_shader_glsl/simple_shader.v'
 			skip_files << 'examples/sokol/02_cubes_glsl/cube_glsl.v'
 			skip_files << 'examples/sokol/03_march_tracing_glsl/rt_glsl.v'
 			skip_files << 'examples/sokol/04_multi_shader_glsl/rt_glsl.v'
@@ -161,6 +216,7 @@ pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 		}
 		if testing.github_job != 'ubuntu-tcc' {
 			skip_files << 'examples/c_interop_wkhtmltopdf.v' // needs installation of wkhtmltopdf from https://github.com/wkhtmltopdf/packaging/releases
+			skip_files << 'examples/call_v_from_python/test.v' // the example only makes sense to be compiled, when python is installed
 			// the ttf_test.v is not interactive, but needs X11 headers to be installed, which is done only on ubuntu-tcc for now
 			skip_files << 'vlib/x/ttf/ttf_test.v'
 			skip_files << 'vlib/vweb/vweb_app_test.v' // imports the `sqlite` module, which in turn includes sqlite3.h
@@ -170,6 +226,9 @@ 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'
+		}
 	}
 	vargs := _vargs.replace('-progress', '').replace('-progress', '')
 	vexe := pref.vexe_path()
@@ -182,6 +241,7 @@ pub fn new_test_session(_vargs string, will_compile bool) TestSession {
 		vexe: vexe
 		vroot: vroot
 		skip_files: skip_files
+		fail_fast: testing.fail_fast
 		vargs: vargs
 		vtmp_dir: new_vtmp_dir
 		silent_mode: _vargs.contains('-silent')
@@ -209,8 +269,7 @@ pub fn (mut ts TestSession) test() {
 	ts.init()
 	mut remaining_files := []string{}
 	for dot_relative_file in ts.files {
-		relative_file := dot_relative_file.replace('./', '')
-		file := os.real_path(relative_file)
+		file := os.real_path(dot_relative_file)
 		$if windows {
 			if file.contains('sqlite') || file.contains('httpbin') {
 				continue
@@ -231,6 +290,11 @@ pub fn (mut ts TestSession) test() {
 	remaining_files = vtest.filter_vtest_only(remaining_files, fix_slashes: false)
 	ts.files = remaining_files
 	ts.benchmark.set_total_expected_steps(remaining_files.len)
+	mut njobs := runtime.nr_jobs()
+	if remaining_files.len < njobs {
+		njobs = remaining_files.len
+	}
+	ts.benchmark.njobs = njobs
 	mut pool_of_test_runners := pool.new_pool_processor(callback: worker_trunner)
 	// for handling messages across threads
 	ts.nmessages = chan LogMessage{cap: 10000}
@@ -243,17 +307,26 @@ pub fn (mut ts TestSession) test() {
 	ts.append_message(.sentinel, '') // send the sentinel
 	_ := <-ts.nprint_ended // wait for the stop of the printing thread
 	eprintln(term.h_divider('-'))
-	// cleanup generated .tmp.c files after successfull tests:
+	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 { panic(err) }
+			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())
+	if ts.fail_fast {
+		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
@@ -264,8 +337,25 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 		p.set_thread_context(idx, tls_bench)
 	}
 	tls_bench.no_cstep = true
-	dot_relative_file := p.get_item<string>(idx)
-	mut relative_file := dot_relative_file.replace('./', '')
+	tls_bench.njobs = ts.benchmark.njobs
+	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 produces_file_output {
+			cmd_options << ' -b js'
+			run_js = true
+		}
+	}
+
+	if relative_file.contains('global') && !is_fmt {
+		cmd_options << ' -enable-globals'
+	}
 	if ts.root_relative {
 		relative_file = relative_file.replace(ts.vroot + os.path_separator, '')
 	}
@@ -274,22 +364,22 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 	// Ensure that the generated binaries will be stored in the temporary folder.
 	// Remove them after a test passes/fails.
 	fname := os.file_name(file)
-	generated_binary_fname := if os.user_os() == 'windows' {
+	generated_binary_fname := if os.user_os() == 'windows' && !run_js {
 		fname.replace('.v', '.exe')
+	} else if !run_js {
+		fname.replace('.v', '')
 	} else {
 		fname.replace('.v', '')
 	}
-	generated_binary_fpath := os.join_path(tmpd, generated_binary_fname)
-	if os.exists(generated_binary_fpath) {
+	generated_binary_fpath := os.join_path_single(tmpd, generated_binary_fname)
+	if produces_file_output {
 		if ts.rm_binaries {
-			os.rm(generated_binary_fpath) or { panic(err) }
+			os.rm(generated_binary_fpath) or {}
 		}
+
+		cmd_options << ' -o ${os.quoted_path(generated_binary_fpath)}'
 	}
-	mut cmd_options := [ts.vargs]
-	if !ts.vargs.contains('fmt') {
-		cmd_options << ' -o "$generated_binary_fpath"'
-	}
-	cmd := '"$ts.vexe" ' + cmd_options.join(' ') + ' "$file"'
+	cmd := '${os.quoted_path(ts.vexe)} ' + cmd_options.join(' ') + ' ${os.quoted_path(file)}'
 	ts.benchmark.step()
 	tls_bench.step()
 	if relative_file.replace('\\', '/') in ts.skip_files {
@@ -302,24 +392,42 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 	}
 	if show_stats {
 		ts.append_message(.ok, term.h_divider('-'))
-		status := os.system(cmd)
-		if status == 0 {
-			ts.benchmark.ok()
-			tls_bench.ok()
-		} else {
-			ts.failed = true
+		mut status := os.system(cmd)
+		if status != 0 {
+			details := get_test_details(file)
+			os.setenv('VTEST_RETRY_MAX', '$details.retry', true)
+			for retry := 1; retry <= details.retry; retry++ {
+				ts.append_message(.info, '  [stats]        retrying $retry/$details.retry of $relative_file ; known flaky: $details.flaky ...')
+				os.setenv('VTEST_RETRY', '$retry', true)
+				status = os.system(cmd)
+				if status == 0 {
+					unsafe {
+						goto test_passed_system
+					}
+				}
+				time.sleep(500 * time.millisecond)
+			}
+			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 .')
+				unsafe {
+					goto test_passed_system
+				}
+			}
 			ts.benchmark.fail()
 			tls_bench.fail()
 			ts.add_failed_cmd(cmd)
 			return pool.no_result
+		} else {
+			test_passed_system:
+			ts.benchmark.ok()
+			tls_bench.ok()
 		}
 	} else {
 		if testing.show_start {
 			ts.append_message(.info, '                 starting $relative_file ...')
 		}
-		r := os.execute(cmd)
+		mut r := os.execute(cmd)
 		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))
@@ -327,13 +435,31 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 			return pool.no_result
 		}
 		if r.exit_code != 0 {
-			ts.failed = true
+			details := get_test_details(file)
+			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 ; known flaky: $details.flaky ...')
+				os.setenv('VTEST_RETRY', '$retry', true)
+				r = os.execute(cmd)
+				if r.exit_code == 0 {
+					unsafe {
+						goto test_passed_execute
+					}
+				}
+			}
+			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 .')
+				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.add_failed_cmd(cmd)
 		} else {
+			test_passed_execute:
 			ts.benchmark.ok()
 			tls_bench.ok()
 			if !testing.hide_oks {
@@ -341,26 +467,20 @@ fn worker_trunner(mut p pool.PoolProcessor, idx int, thread_id int) voidptr {
 			}
 		}
 	}
-	if os.exists(generated_binary_fpath) {
-		if ts.rm_binaries {
-			os.rm(generated_binary_fpath) or { panic(err) }
-		}
+	if produces_file_output && ts.rm_binaries {
+		os.rm(generated_binary_fpath) or {}
 	}
 	return pool.no_result
 }
 
 pub fn vlib_should_be_present(parent_dir string) {
-	vlib_dir := os.join_path(parent_dir, 'vlib')
+	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')
 		exit(1)
 	}
 }
 
-pub fn v_build_failing(zargs string, folder string) bool {
-	return v_build_failing_skipped(zargs, folder, [])
-}
-
 pub fn prepare_test_session(zargs string, folder string, oskipped []string, main_label string) TestSession {
 	vexe := pref.vexe_path()
 	parent_dir := os.dir(vexe)
@@ -371,17 +491,17 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 		eprintln('v compiler args: "$vargs"')
 	}
 	mut session := new_test_session(vargs, true)
-	files := os.walk_ext(os.join_path(parent_dir, folder), '.v')
+	files := os.walk_ext(os.join_path_single(parent_dir, folder), '.v')
 	mut mains := []string{}
 	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 {
@@ -392,14 +512,15 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 			}
 		}
 		c := os.read_file(f) or { panic(err) }
-		maxc := if c.len > 300 { 300 } else { c.len }
+		maxc := if c.len > 500 { 500 } else { c.len }
 		start := c[0..maxc]
 		if start.contains('module ') && !start.contains('module main') {
-			skipped_f := f.replace(os.join_path(parent_dir, ''), '')
+			skipped_f := f.replace(os.join_path_single(parent_dir, ''), '')
 			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
 			}
 		}
@@ -410,13 +531,16 @@ pub fn prepare_test_session(zargs string, folder string, oskipped []string, main
 	return session
 }
 
-pub fn v_build_failing_skipped(zargs string, folder string, oskipped []string) bool {
+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'
 	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 {
@@ -438,12 +562,11 @@ pub fn building_any_v_binaries_failed() bool {
 	vexe := pref.vexe_path()
 	parent_dir := os.dir(vexe)
 	vlib_should_be_present(parent_dir)
-	os.chdir(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',
-	]
+		'$vexe -o v_prod    -prod     cmd/v']
 	mut bmark := benchmark.new_benchmark()
 	for cmd in v_build_commands {
 		bmark.step()
@@ -471,12 +594,42 @@ pub fn eheader(msg string) {
 
 pub fn header(msg string) {
 	println(term.header_left(msg, '-'))
+	flush_stdout()
 }
 
 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.temp_dir(), 'v', '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
 }
+
+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 {
+	mut res := TestDetails{}
+	lines := os.read_lines(file) or { [] }
+	for line in lines {
+		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 {
+	for line in testing.all_processes {
+		if line.contains(pname) {
+			return line
+		}
+	}
+	return error('could not find process matching $pname')
+}

cmd/tools/modules/vgit/vgit.v

@@ -75,8 +75,8 @@ pub fn prepare_vc_source(vcdir string, cdir string, commit string) (string, stri
 }
 
 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
-	if os.is_dir(local_worktree_path) && os.is_dir(os.join_path(local_worktree_path, '.git')) {
+	// 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 ')
@@ -107,15 +107,15 @@ pub mut:
 
 pub fn (mut vgit_context VGitContext) compile_oldv_if_needed() {
 	vgit_context.vexename = if os.user_os() == 'windows' { 'v.exe' } else { 'v' }
-	vgit_context.vexepath = os.real_path(os.join_path(vgit_context.path_v, vgit_context.vexename))
+	vgit_context.vexepath = os.real_path(os.join_path_single(vgit_context.path_v, vgit_context.vexename))
 	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 -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 -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)
@@ -146,7 +146,7 @@ pub fn (mut vgit_context VGitContext) compile_oldv_if_needed() {
 		scripting.run('make fresh_tcc')
 	}
 	scripting.run(command_for_building_v_from_c_source)
-	build_cmd := command_for_selfbuilding.replace('{SOURCE}', vgit_context.vvlocation)
+	build_cmd := command_for_selfbuilding.replace('\{SOURCE}', vgit_context.vvlocation)
 	scripting.run(build_cmd)
 	// At this point, there exists a file vgit_context.vexepath
 	// which should be a valid working V executable.

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)
 	}
@@ -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,6 +143,10 @@ 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')
 	}
@@ -171,6 +177,9 @@ fn main() {
 		}
 		scripting.cprint_strong('#            result: ')
 		print(cmdres.output)
+		if !cmdres.output.ends_with('\n') {
+			println('')
+		}
 		exit(cmdres.exit_code)
 	}
 }

cmd/tools/performance_compare.v

@@ -56,15 +56,18 @@ fn (c Context) compare_versions() {
 		'v     @DEBUG@ -o source.c examples/hello_world.v',
 		'v             -o source.c examples/hello_world.v',
 	])
-	perf_files << c.compare_v_performance('source_v', ['vprod @DEBUG@ -o source.c @COMPILER@',
-		'vprod         -o source.c @COMPILER@', 'v     @DEBUG@ -o source.c @COMPILER@',
+	perf_files << c.compare_v_performance('source_v', [
+		'vprod @DEBUG@ -o source.c @COMPILER@',
+		'vprod         -o source.c @COMPILER@',
+		'v     @DEBUG@ -o source.c @COMPILER@',
 		'v             -o source.c @COMPILER@',
 	])
 	perf_files << c.compare_v_performance('binary_hello', [
 		'vprod         -o hello    examples/hello_world.v',
 		'v             -o hello    examples/hello_world.v',
 	])
-	perf_files << c.compare_v_performance('binary_v', ['vprod         -o binary   @COMPILER@',
+	perf_files << c.compare_v_performance('binary_v', [
+		'vprod         -o binary   @COMPILER@',
 		'v             -o binary   @COMPILER@',
 	])
 	println('All performance files:')
@@ -107,8 +110,7 @@ fn (c &Context) prepare_v(cdir string, commit string) {
 	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',
-	])
+		'$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')
@@ -192,7 +194,7 @@ 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:

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

@@ -6,7 +6,6 @@ import time
 import term
 import math
 import scripting
-import v.util
 
 struct CmdResult {
 mut:
@@ -127,8 +126,12 @@ fn new_aints(ovals []int, extreme_mins int, extreme_maxs int) Aints {
 	return res
 }
 
+fn bold(s string) string {
+	return term.colorize(term.bold, s)
+}
+
 fn (a Aints) str() string {
-	return util.bold('${a.average:6.2f}') +
+	return bold('${a.average:6.2f}') +
 		'ms ± σ: ${a.stddev:4.1f}ms, min: ${a.imin:4}ms, max: ${a.imax:4}ms, runs:${a.values.len:3}, nmins:${a.nmins:2}, nmaxs:${a.nmaxs:2}'
 }
 
@@ -140,30 +143,30 @@ 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).')
-	context.cmd_template = fp.string('template', `t`, '{T}', 'Command template. {T} will be substituted with the current command.')
-	cmd_params := fp.string_multi('parameter', `p`, 'A parameter substitution list. `{p}=val1,val2,val2` means that {p} in the template, will be substituted with each of val1, val2, val3.')
+	context.cmd_template = fp.string('template', `t`, r'{T}', r'Command template. {T} will be substituted with the current command.')
+	cmd_params := fp.string_multi('parameter', `p`, r'A parameter substitution list. `{p}=val1,val2,val2` means that {p} in the template, will be substituted with each of val1, val2, val3.')
 	context.nmins = fp.int('nmins', `i`, 0, 'Ignore the BOTTOM X results (minimum execution time). Makes the results more robust to performance flukes.')
 	context.nmaxs = fp.int('nmaxs', `a`, 1, 'Ignore the TOP X results (maximum execution time). Makes the results more robust to performance flukes.')
 	for p in cmd_params {
@@ -197,14 +200,19 @@ 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 {
 	mut all_commands := []string{}
 	for cmd in commands {
-		maincmd := context.cmd_template.replace('{T}', cmd)
+		maincmd := context.cmd_template.replace(r'{T}', cmd)
 		mut substituted_commands := []string{}
 		substituted_commands << maincmd
 		for paramk, paramlist in context.cmd_params {
@@ -244,7 +252,7 @@ fn (mut context Context) run() {
 			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 {
@@ -257,9 +265,9 @@ 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 }
@@ -285,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 {
@@ -346,7 +354,7 @@ fn (mut context Context) show_diff_summary() {
 		first_marker = ' '
 		cpercent := (r.atiming.average / base) * 100 - 100
 		if r.icmd == 0 {
-			first_marker = util.bold('>')
+			first_marker = bold('>')
 			first_cmd_percentage = cpercent
 		}
 		println(' $first_marker${(i + 1):3} | ${cpercent:5.1f}% slower | ${r.cmd:-57s} | $r.atiming')
@@ -355,7 +363,7 @@ fn (mut context Context) show_diff_summary() {
 		println('context: $context')
 	}
 	if int(base) > context.fail_on_maxtime {
-		print(performance_regression_label)
+		flushed_print(performance_regression_label)
 		println('average time: ${base:6.1f} ms > $context.fail_on_maxtime ms threshold.')
 		exit(2)
 	}
@@ -364,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()
 )
@@ -26,34 +26,69 @@ 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.temp_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')
-	os.rmdir_all(tdir) or { panic(err) }
+	os.rmdir_all(tdir) or { eprintln(err) }
 }
 
-fn main() {
-	println('> vroot: $vroot | vexe: $vexe | tdir: $tdir')
-	ok_fpath := os.join_path(tdir, 'single_test.v')
-	os.write_file(ok_fpath, 'fn test_ok(){ assert true }') ?
-	check_ok('"$vexe" $ok_fpath')
-	check_ok('"$vexe" test $ok_fpath')
-	fail_fpath := os.join_path(tdir, 'failing_test.v')
-	os.write_file(fail_fpath, 'fn test_fail(){ assert 1 == 2 }') ?
-	check_fail('"$vexe" $fail_fpath')
-	check_fail('"$vexe" test $fail_fpath')
-	check_fail('"$vexe" test $tdir')
+type MyResult = string
+
+[noreturn]
+fn (result MyResult) fail(reason string) {
+	eprintln('> $reason, but it does not. Result:\n$result')
+	exit(1)
 }
 
-fn check_ok(cmd string) string {
+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 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 {
@@ -63,7 +98,7 @@ fn check_ok(cmd string) string {
 	return res.output
 }
 
-fn check_fail(cmd string) string {
+fn check_fail(cmd string) MyResult {
 	println('> check_fail cmd: $cmd')
 	res := os.execute(cmd)
 	if res.exit_code == 0 {
@@ -72,3 +107,29 @@ fn check_fail(cmd string) string {
 	}
 	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 }')!
+	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)!
+	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')
+}

cmd/tools/translate.v

@@ -0,0 +1,53 @@
+// Copyright (c) 2019-2022 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 {

cmd/tools/vast/test/demo.v

@@ -119,3 +119,13 @@ struct GenericStruct<T> {
 mut:
 	model T
 }
+
+// generic interface
+interface Gettable<T> {
+	get() T
+}
+
+// generic sumtype
+struct None {}
+
+type MyOption<T> = Error | None | T

cmd/tools/vbin2v.v

@@ -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')
 	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++ {
@@ -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') }
+	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

@@ -1,4 +1,3 @@
-import dl
 import net.urllib
 import os
 import readline
@@ -9,7 +8,7 @@ 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('$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')
 		return ''
@@ -22,19 +21,19 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 	mut vexe := os.getenv('VEXE')
 	// prepare a V compiler with -g to have better backtraces if possible
 	wd := os.getwd()
-	os.chdir(vroot)
+	os.chdir(vroot) or {}
 	verbose_flag := if is_verbose { '-v' } else { '' }
 	vdbg_path := $if windows { '$vroot/vdbg.exe' } $else { '$vroot/vdbg' }
-	vdbg_compilation_cmd := '"$vexe" $verbose_flag -g -o "$vdbg_path" cmd/v'
+	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)
+	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')
 	}
 	//
-	mut result := os.execute('"$vexe" $verbose_flag "$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 {
@@ -57,7 +56,7 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 		run := is_yes
 			|| ask('It looks like the compilation went well, do you want to run the file?')
 		if run {
-			result = os.execute('"$vexe" $verbose_flag run "$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,46 +65,6 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string) string {
 	return result.output
 }
 
-type ShellExecuteWin = fn (voidptr, &u16, &u16, &u16, &u16, int)
-
-// open a uri using the default associated application
-fn open_browser(uri string) ? {
-	$if macos {
-		result := os.execute('open "$uri"')
-		if result.exit_code != 0 {
-			return error('unable to open url: $result.output')
-		}
-	} $else $if freebsd || openbsd {
-		result := os.execute('xdg-open "$uri"')
-		if result.exit_code != 0 {
-			return error('unable to open url: $result.output')
-		}
-	} $else $if linux {
-		providers := ['xdg-open', 'x-www-browser', 'www-browser', 'wslview']
-
-		// There are multiple possible providers to open a browser on linux
-		// One of them is xdg-open, another is x-www-browser, then there's www-browser, etc.
-		// Look for one that exists and run it
-		for provider in providers {
-			if os.exists_in_system_path(provider) {
-				result := os.execute('$provider "$uri"')
-				if result.exit_code != 0 {
-					return error('unable to open url: $result.output')
-				}
-				break
-			}
-		}
-	} $else $if windows {
-		handle := dl.open_opt('shell32', dl.rtld_now) ?
-		// https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shellexecutew
-		func := ShellExecuteWin(dl.sym_opt(handle, 'ShellExecuteW') ?)
-		func(C.NULL, 'open'.to_wide(), uri.to_wide(), C.NULL, C.NULL, C.SW_SHOWNORMAL)
-		dl.close(handle)
-	} $else {
-		return error('unsupported platform')
-	}
-}
-
 fn ask(msg string) bool {
 	prompt := os.input_opt('$msg [Y/n] ') or { 'y' }
 	return prompt == '' || prompt[0].ascii_str().to_lower() != 'n'
@@ -146,6 +105,7 @@ fn main() {
 		eprintln('v bug: no v file listed to report')
 		exit(1)
 	}
+	os.unsetenv('VCOLORS')
 	// collect error information
 	// output from `v doctor`
 	vdoctor_output := get_vdoctor_output(is_verbose)
@@ -158,7 +118,7 @@ fn main() {
 	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 {
@@ -176,11 +136,12 @@ 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`
-{file_content}
+\{file_content}
 
 **What did you expect to see?**
 
@@ -189,16 +150,16 @@ $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 encoded_body := urllib.query_escape(raw_body.replace_once(r'{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`'))
+		encoded_body = urllib.query_escape(raw_body.replace_once(r'{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 {
-		open_browser(generated_uri) or {
+		os.open_uri(generated_uri) or {
 			if is_verbose {
 				eprintln(err)
 			}

cmd/tools/vbuild-examples.v

@@ -3,13 +3,31 @@ module main
 import os
 import testing
 
+const vroot = @VMODROOT
+
+// build as a project folder
+const efolders = [
+	'examples/viewer',
+	'examples/vweb_orm_jwt',
+]
+
 fn main() {
 	args_string := os.args[1..].join(' ')
 	params := args_string.all_before('build-examples')
-	if testing.v_build_failing(params, 'examples') {
+	skip_prefixes := efolders.map(os.real_path(os.join_path_single(vroot, it)).replace('\\',
+		'/'))
+	res := testing.v_build_failing_skipped(params, 'examples', skip_prefixes, fn (mut session testing.TestSession) {
+		for x in efolders {
+			pathsegments := x.split_any('/')
+			session.add(os.real_path(os.join_path(vroot, ...pathsegments)))
+		}
+	})
+	if res {
 		exit(1)
 	}
-	if testing.v_build_failing(params + '-live', os.join_path('examples', 'hot_reload')) {
+	if testing.v_build_failing_skipped(params + '-live', os.join_path_single('examples',
+		'hot_reload'), skip_prefixes, fn (mut session testing.TestSession) {})
+	{
 		exit(1)
 	}
 }

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']
 
 // non_packaged_tools are tools that should not be packaged with
 // prebuild versions of V, to keep the size smaller.
@@ -23,7 +23,7 @@ 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 ...'
@@ -31,7 +31,7 @@ fn main() {
 	//
 	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), '')
@@ -56,14 +56,19 @@ fn main() {
 		}
 		//
 		tpath := os.join_path(session.vtmp_dir, texe)
+		if texe.ends_with('_builder') || texe.ends_with('_builder.exe') {
+			os.mv_by_cp(tpath, os.join_path(tfolder, 'builders', texe)) or { panic(err) }
+			continue
+		}
 		if tname in tools_in_subfolders {
 			os.mv_by_cp(tpath, os.join_path(tfolder, tname, texe)) or { panic(err) }
 			continue
 		}
 		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

@@ -0,0 +1,188 @@
+// Copyright (c) 2019-2022 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
+
+import flag
+import os
+import regex
+import semver
+
+const (
+	tool_name        = os.file_name(os.executable())
+	tool_version     = '0.0.1'
+	tool_description = '\n  Bump the semantic version of the v.mod and/or specified files.
+
+  The first instance of a version number is replaced with the new version.
+  Additionally, the line affected must contain the word "version" in any
+  form of capitalization. For instance, the following lines will be
+  recognized by the heuristic:
+
+    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
+  Bump the major version in v.mod and vls.v
+    v bump --major v.mod vls.v
+  Upgrade the minor version in sample.v only
+    v bump --minor sample.v
+'
+	semver_query = r'((0)|([1-9]\d*)\.){2}(0)|([1-9]\d*)(\-[\w\d\.\-_]+)?(\+[\w\d\.\-_]+)?'
+)
+
+struct Options {
+	show_help bool
+	major     bool
+	minor     bool
+	patch     bool
+}
+
+type ReplacementFunction = fn (re regex.RE, input string, start int, end int) string
+
+fn replace_with_increased_patch_version(re regex.RE, input string, start int, end int) string {
+	version := semver.from(input[start..end]) or { return input }
+	return version.increment(.patch).str()
+}
+
+fn replace_with_increased_minor_version(re regex.RE, input string, start int, end int) string {
+	version := semver.from(input[start..end]) or { return input }
+	return version.increment(.minor).str()
+}
+
+fn replace_with_increased_major_version(re regex.RE, input string, start int, end int) string {
+	version := semver.from(input[start..end]) or { return input }
+	return version.increment(.major).str()
+}
+
+fn get_replacement_function(options Options) ReplacementFunction {
+	if options.patch {
+		return replace_with_increased_patch_version
+	} else if options.minor {
+		return replace_with_increased_minor_version
+	} else if options.major {
+		return replace_with_increased_major_version
+	}
+	return replace_with_increased_patch_version
+}
+
+fn process_file(input_file string, options Options) {
+	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.') }
+
+	repl_fn := get_replacement_function(options)
+
+	mut new_lines := []string{cap: lines.len}
+	mut replacement_complete := false
+
+	for line in lines {
+		// Copy over the remaining lines normally if the replacement is complete
+		if replacement_complete {
+			new_lines << line
+			continue
+		}
+
+		// Check if replacement is necessary
+		updated_line := if line.to_lower().contains('version') {
+			replacement_complete = true
+			re.replace_by_fn(line, repl_fn)
+		} else {
+			line
+		}
+		new_lines << updated_line
+	}
+
+	// Add a trailing newline
+	new_lines << ''
+
+	backup_file := input_file + '.cache'
+
+	// Remove the backup file if it exists.
+	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') }
+
+	// 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')
+	}
+
+	// Remove the backup file.
+	os.rm(backup_file) or {}
+
+	if replacement_complete {
+		println('Bumped version in $input_file')
+	} else {
+		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...')
+		exit(1)
+	}
+
+	mut fp := flag.new_flag_parser(os.args)
+
+	fp.application(tool_name)
+	fp.version(tool_version)
+	fp.description(tool_description)
+	fp.arguments_description('[file1 file2 ...]')
+	fp.skip_executable()
+
+	options := Options{
+		show_help: fp.bool('help', `h`, false, 'Show this help text.')
+		patch: fp.bool('patch', `p`, false, 'Bump the patch version.')
+		minor: fp.bool('minor', `n`, false, 'Bump the minor version.')
+		major: fp.bool('major', `m`, false, 'Bump the major version.')
+	}
+
+	if options.show_help {
+		println(fp.usage())
+		exit(0)
+	}
+
+	validate_options(options) or { panic(err) }
+
+	files := os.args[3..]
+
+	if files.len == 0 {
+		if !os.exists('v.mod') {
+			println('v.mod does not exist. You can create one using "v init".')
+			exit(1)
+		}
+		process_file('v.mod', options)
+	}
+
+	for input_file in files {
+		if !os.exists(input_file) {
+			println('File not found: $input_file')
+			exit(1)
+		}
+		process_file(input_file, options)
+	}
+}
+
+fn validate_options(options Options) ? {
+	if options.patch && options.major {
+		return error('Cannot specify both --patch and --major.')
+	}
+
+	if options.patch && options.minor {
+		return error('Cannot specify both --patch and --minor.')
+	}
+
+	if options.major && options.minor {
+		return error('Cannot specify both --major and --minor.')
+	}
+
+	if !(options.patch || options.major || options.minor) {
+		return error('Must specify one of --patch, --major, or --minor.')
+	}
+}

cmd/tools/vbump_test.v

@@ -0,0 +1,101 @@
+import os
+
+const vexe = @VEXE
+
+const tfolder = os.join_path(os.temp_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
+	line           int
+	expected_patch string
+	expected_minor string
+	expected_major string
+}
+
+const test_cases = [
+	BumpTestCase{
+		file_name: 'v.mod'
+		contents: "Module {
+	name: 'Sample'
+	description: 'Sample project'
+	version: '1.2.6'
+	license: 'MIT'
+	dependencies: []
+}
+
+"
+		line: 3
+		expected_patch: "	version: '1.2.7'"
+		expected_minor: "	version: '1.3.0'"
+		expected_major: "	version: '2.0.0'"
+	},
+	BumpTestCase{
+		file_name: 'random_versions.vv'
+		contents: "
+1.1.2
+1.2.5
+3.21.73
+version = '1.5.1'
+
+"
+		line: 4
+		expected_patch: "version = '1.5.2'"
+		expected_minor: "version = '1.6.0'"
+		expected_major: "version = '2.0.0'"
+	},
+	BumpTestCase{
+		file_name: 'sample_tool.v'
+		contents: "// Module comment and copyright information
+import os
+import flag
+
+const (
+	tool_name        = os.file_name(os.executable())
+	tool_version     = '0.1.33'
+)
+fn main() {
+	// stuff
+}
+	"
+		line: 6
+		expected_patch: "	tool_version     = '0.1.34'"
+		expected_minor: "	tool_version     = '0.2.0'"
+		expected_major: "	tool_version     = '1.0.0'"
+	},
+]
+
+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.execute_or_exit('${os.quoted_path(vexe)} bump --patch ${os.quoted_path(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)!
+	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)!
+	assert major_lines[case.line] == case.expected_major
+	//
+	os.rm(test_file)!
+}
+
+fn test_all_bump_cases() {
+	for case in test_cases {
+		run_individual_test(case) or { panic(err) }
+	}
+}

cmd/tools/vcheck-md.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2022 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
@@ -8,15 +8,22 @@ import os.cmdline
 import rand
 import term
 import vhelp
-import v.pref
 import regex
 
 const (
-	too_long_line_length = 100
-	term_colors          = term.can_show_color_on_stderr()
-	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..])
+	too_long_line_length_example   = 120
+	too_long_line_length_codeblock = 120
+	too_long_line_length_table     = 120
+	too_long_line_length_link      = 150
+	too_long_line_length_other     = 100
+	term_colors                    = term.can_show_color_on_stderr()
+	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.temp_dir(), 'v', 'vcheck_$os.getuid()')
+	should_autofix                 = os.getenv('VAUTOFIX') != ''
+	vexe                           = @VEXE
 )
 
 struct CheckResult {
@@ -52,6 +59,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) {
@@ -71,7 +82,7 @@ fn main() {
 		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')
@@ -127,9 +138,7 @@ fn eline(file_path string, lnumber int, column int, message string) string {
 	return btext('$file_path:${lnumber + 1}:${column + 1}:') + btext(rtext(' error: $message'))
 }
 
-const (
-	default_command = 'compile'
-)
+const default_command = 'compile'
 
 struct VCodeExample {
 mut:
@@ -146,9 +155,9 @@ enum MDFileParserState {
 }
 
 struct MDFile {
-	path  string
-	lines []string
+	path string
 mut:
+	lines    []string
 	examples []VCodeExample
 	current  VCodeExample
 	state    MDFileParserState = .markdown
@@ -156,7 +165,7 @@ mut:
 
 fn (mut f MDFile) progress(message string) {
 	if show_progress {
-		term.clear_previous_line()
+		clear_previous_line()
 		println('File: ${f.path:-30s}, Lines: ${f.lines.len:5}, $message')
 	}
 }
@@ -166,28 +175,34 @@ fn (mut f MDFile) check() CheckResult {
 	mut anchor_data := AnchorData{}
 	for j, line in f.lines {
 		// f.progress('line: $j')
-		if line.len > too_long_line_length {
-			if f.state == .vexample {
-				wprintln(wline(f.path, j, line.len, 'long V example line'))
+		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 {
-				wprintln(wline(f.path, j, line.len, 'long code block line'))
-				wprintln(line)
-				res.warnings++
-			} else if line.starts_with('|') {
-				wprintln(wline(f.path, j, line.len, 'long table'))
-				wprintln(line)
-				res.warnings++
-			} else if line.contains('https') {
-				wprintln(wline(f.path, j, line.len, 'long link'))
-				wprintln(line)
-				res.warnings++
-			} else {
-				eprintln(eline(f.path, j, line.len, 'line too long'))
-				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)
@@ -328,7 +343,7 @@ fn (mut ad AnchorData) check_link_target_match(fpath string, mut res CheckResult
 		}
 	}
 	for link, anchor_lists in ad.anchors {
-		if !(link in checked_headlines) {
+		if link !in checked_headlines {
 			if anchor_lists.len > 1 {
 				for anchor in anchor_lists {
 					line := match anchor {
@@ -384,6 +399,7 @@ fn (mut f MDFile) debug() {
 }
 
 fn cmdexecute(cmd string) int {
+	verbose_println(cmd)
 	res := os.execute(cmd)
 	if res.exit_code < 0 {
 		return 1
@@ -395,19 +411,19 @@ fn cmdexecute(cmd string) int {
 }
 
 fn silent_cmdexecute(cmd string) int {
+	verbose_println(cmd)
 	res := os.execute(cmd)
 	return res.exit_code
 }
 
 fn get_fmt_exit_code(vfile string, vexe string) int {
-	return silent_cmdexecute('"$vexe" fmt -verify $vfile')
+	return silent_cmdexecute('${os.quoted_path(vexe)} fmt -verify ${os.quoted_path(vfile)}')
 }
 
 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
 		}
@@ -416,7 +432,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'
@@ -428,14 +446,33 @@ fn (mut f MDFile) check_examples() CheckResult {
 			fmt_res := if nofmt { 0 } else { get_fmt_exit_code(vfile, vexe) }
 			match command {
 				'compile' {
-					res := cmdexecute('"$vexe" -w -Wfatal-errors -o x.c $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
@@ -445,14 +482,15 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'globals' {
-					res := cmdexecute('"$vexe" -w -Wfatal-errors -enable-globals -o x.c $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
@@ -462,13 +500,15 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'live' {
-					res := cmdexecute('"$vexe" -w -Wfatal-errors -live -o x.c $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
@@ -478,14 +518,15 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'failcompile' {
-					res := silent_cmdexecute('"$vexe" -w -Wfatal-errors -o x.c $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
@@ -495,13 +536,29 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'oksyntax' {
-					res := cmdexecute('"$vexe" -w -Wfatal-errors -check-syntax $vfile')
+					res := cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -check-syntax ${os.quoted_path(vfile)}')
 					if res != 0 || fmt_res != 0 {
 						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
@@ -511,7 +568,7 @@ fn (mut f MDFile) check_examples() CheckResult {
 					oks++
 				}
 				'badsyntax' {
-					res := silent_cmdexecute('"$vexe" -w -Wfatal-errors -check-syntax $vfile')
+					res := silent_cmdexecute('${os.quoted_path(vexe)} -w -Wfatal-errors -check-syntax ${os.quoted_path(vfile)}')
 					if res == 0 {
 						eprintln(eline(f.path, e.sline, 0, '`badsyntax` example can be parsed fine'))
 						eprintln(vcontent)
@@ -523,12 +580,14 @@ fn (mut f MDFile) check_examples() CheckResult {
 				}
 				'nofmt' {}
 				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/cgen/failcompile/okfmt/oksyntax/badsyntax/nofmt'))
 					should_cleanup_vfile = false
 					errors++
 				}
 			}
 		}
+		os.rm(cfile) or {}
+		os.rm(efile) or {}
 		if should_cleanup_vfile {
 			os.rm(vfile) or { panic(err) }
 		}
@@ -538,3 +597,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-2021 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
 // Use of this source code is governed by an MIT license
 // that can be found in the LICENSE file.
 //
@@ -44,36 +44,77 @@ import os
 const (
 	auto_complete_shells = ['bash', 'fish', 'zsh', 'powershell'] // list of supported shells
 	vexe                 = os.getenv('VEXE')
+	help_text            = "Usage:
+  v complete [options] [SUBCMD] QUERY...
+
+Description:
+  Tool for bridging auto completion between various shells and v
+
+Supported shells:
+  bash, fish, zsh, powershell
+
+Examples:
+  Echo auto-detected shell install script to STDOUT
+    v complete
+  Echo specific shell install script to STDOUT
+    v complete setup bash
+  Auto complete input `v tes`*USER PUSHES TAB* (in Bash compatible format).
+  This is not meant for manual invocation - it's called by the relevant
+  shell via the script installed with `v complete` or `v complete setup SHELL`.
+    v complete bash v tes
+
+Options:
+  -h, --help                Show this help text.
+
+SUBCMD:
+  setup     : setup [SHELL] - returns the code for completion setup for SHELL
+  bash      : [QUERY]       - returns Bash compatible completion code with completions computed from QUERY
+  fish      : [QUERY]       - returns Fish compatible completion code with completions computed from QUERY
+  zsh       : [QUERY]       - returns ZSH  compatible completion code with completions computed from QUERY
+  powershell: [QUERY]       - returns PowerShell compatible completion code with completions computed from QUERY"
 )
 
 // Snooped from cmd/v/v.v, vlib/v/pref/pref.v
 const (
-	auto_complete_commands    = [
+	auto_complete_commands      = [
 		// simple_cmd
-		'fmt',
-		'up',
-		'vet',
-		'self',
-		'tracev',
-		'symlink',
-		'bin2v',
-		'test',
-		'test-fmt',
-		'test-self',
-		'test-cleancode',
-		'repl',
-		'complete',
-		'build-tools',
-		'build-examples',
-		'build-vbinaries',
-		'setup-freetype',
+		'ast',
 		'doc',
+		'vet',
+		// tools in one .v file
+		'bin2v',
+		'bug',
+		'build-examples',
+		'build-tools',
+		'build-vbinaries',
+		'bump',
+		'check-md',
+		'complete',
+		'compress',
+		'create',
 		'doctor',
+		'fmt',
+		'gret',
+		'ls',
+		'repl',
+		'self',
+		'setup-freetype',
+		'shader',
+		'symlink',
+		'test-all',
+		'test-cleancode',
+		'test-fmt',
+		'test-parser',
+		'test-self',
+		'test',
+		'tracev',
+		'up',
+		'watch',
+		'wipe-cache',
 		// commands
 		'help',
 		'new',
 		'init',
-		'complete',
 		'translate',
 		'self',
 		'search',
@@ -89,11 +130,17 @@ 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',
+		'-check',
 		'-v',
 		'-progress',
 		'-silent',
@@ -108,6 +155,7 @@ const (
 		'-autofree',
 		'-compress',
 		'-freestanding',
+		'-no-parallel',
 		'-no-preludes',
 		'-prof',
 		'-profile',
@@ -131,6 +179,7 @@ const (
 		'-w',
 		'-print-v-files',
 		'-error-limit',
+		'-message-limit',
 		'-os',
 		'-printfn',
 		'-cflags',
@@ -147,7 +196,7 @@ const (
 		'-version',
 		'--version',
 	]
-	auto_complete_flags_doc   = [
+	auto_complete_flags_doc     = [
 		'-all',
 		'-f',
 		'-h',
@@ -160,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',
@@ -173,7 +223,7 @@ const (
 		'-debug',
 		'-verify',
 	]
-	auto_complete_flags_bin2v = [
+	auto_complete_flags_bin2v   = [
 		'-h',
 		'--help',
 		'-m',
@@ -183,10 +233,46 @@ const (
 		'-w',
 		'--write',
 	]
-	auto_complete_flags_self  = [
+	auto_complete_flags_shader  = [
+		'--help',
+		'-h',
+		'--force-update',
+		'-u',
+		'--verbose',
+		'-v',
+		'--slang',
+		'-l',
+		'--output',
+		'-o',
+	]
+	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',
@@ -202,6 +288,16 @@ const (
 fn auto_complete(args []string) {
 	if args.len <= 1 || args[0] != 'complete' {
 		if args.len == 1 {
+			shell_path := os.getenv('SHELL')
+			if shell_path.len > 0 {
+				shell_name := os.file_name(shell_path).to_lower()
+				if shell_name in auto_complete_shells {
+					println(setup_for_shell(shell_name))
+					exit(0)
+				}
+				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".')
@@ -217,62 +313,7 @@ fn auto_complete(args []string) {
 				exit(1)
 			}
 			shell := sub_args[1]
-			mut setup := ''
-			match shell {
-				'bash' {
-					setup = '
-_v_completions() {
-	local src
-	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}))
-	if [[ \$? == 0 ]]; then
-		eval \${src}
-		#echo \${src}
-	fi
-}
-
-complete -o nospace -F _v_completions v
-'
-				}
-				'fish' {
-					setup = '
-function __v_completions
-	# Send all words up to the one before the cursor
-	$vexe complete fish (commandline -cop)
-end
-complete -f -c v -a "(__v_completions)"
-'
-				}
-				'zsh' {
-					setup = '
-#compdef v
-_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]}))
-	if [[ \$? == 0 ]]; then
-		eval \${src}
-		#echo \${src}
-	fi
-}
-compdef _v v
-'
-				}
-				'powershell' {
-					setup = '
-Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
-	param(\$commandName, \$wordToComplete, \$cursorPosition)
-		$vexe complete powershell "\$wordToComplete" | ForEach-Object {
-			[System.Management.Automation.CompletionResult]::new(\$_, \$_, \'ParameterValue\', \$_)
-		}
-}
-'
-				}
-				else {}
-			}
-			println(setup)
+			println(setup_for_shell(shell))
 		}
 		'bash' {
 			if sub_args.len <= 1 {
@@ -307,6 +348,9 @@ Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
 			}
 			println(lines.join('\n'))
 		}
+		'-h', '--help' {
+			println(help_text)
+		}
 		else {}
 	}
 	exit(0)
@@ -321,12 +365,26 @@ fn append_separator_if_dir(path string) string {
 	return path
 }
 
+// nearest_path_or_root returns the nearest valid path searching
+// backwards from `path`.
+fn nearest_path_or_root(path string) string {
+	mut fixed_path := path
+	if !os.is_dir(fixed_path) {
+		fixed_path = path.all_before_last(os.path_separator)
+		if fixed_path == '' {
+			fixed_path = '/'
+		}
+	}
+	return fixed_path
+}
+
 // auto_complete_request retuns 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']).
 	split_by := ' '
 	request := args.join(split_by)
+	mut do_home_expand := false
 	mut list := []string{}
 	// new_part := request.ends_with('\n\n')
 	mut parts := request.trim_right(' ').split(split_by)
@@ -335,7 +393,7 @@ fn auto_complete_request(args []string) []string {
 			list << command
 		}
 	} else {
-		part := parts.last().trim(' ')
+		mut part := parts.last().trim(' ')
 		mut parent_command := ''
 		for i := parts.len - 1; i >= 0; i-- {
 			if parts[i].starts_with('-') {
@@ -344,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)
@@ -366,6 +429,15 @@ fn auto_complete_request(args []string) []string {
 				'self' { // 'v self -<tab>' -> flags.
 					list = get_flags(auto_complete_flags_self, part)
 				}
+				'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 {
@@ -383,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".
@@ -405,17 +482,34 @@ fn auto_complete_request(args []string) []string {
 			mut ls_path := '.'
 			mut collect_all := part in auto_complete_commands
 			mut path_complete := false
+			do_home_expand = part.starts_with('~')
+			if do_home_expand {
+				add_sep := if part == '~' { os.path_separator } else { '' }
+				part = part.replace_once('~', os.home_dir().trim_right(os.path_separator)) + add_sep
+			}
+			is_abs_path := part.starts_with(os.path_separator) // TODO Windows support for drive prefixes
 			if part.ends_with(os.path_separator) || part == '.' || part == '..' {
 				// 'v <command>(.*/$|.|..)<tab>' -> output full directory list
 				ls_path = '.' + os.path_separator + part
+				if is_abs_path {
+					ls_path = nearest_path_or_root(part)
+				}
 				collect_all = true
 			} else if !collect_all && part.contains(os.path_separator) && os.is_dir(os.dir(part)) {
 				// 'v <command>(.*/.* && os.is_dir)<tab>'  -> output completion friendly directory list
-				ls_path = os.dir(part)
+				if is_abs_path {
+					ls_path = nearest_path_or_root(part)
+				} else {
+					ls_path = os.dir(part)
+				}
 				path_complete = true
 			}
+
 			entries := os.ls(ls_path) or { return list }
-			last := part.all_after_last(os.path_separator)
+			mut last := part.all_after_last(os.path_separator)
+			if is_abs_path && os.is_dir(part) {
+				last = ''
+			}
 			if path_complete {
 				path := part.all_before_last(os.path_separator)
 				for entry in entries {
@@ -423,27 +517,80 @@ fn auto_complete_request(args []string) []string {
 						list << append_separator_if_dir(os.join_path(path, entry))
 					}
 				}
-				// If only one possible file - send full path to completion system.
-				// Please note that this might be bash specific - needs more testing.
-				if list.len == 1 {
-					list = [list[0]]
-				}
 			} else {
 				for entry in entries {
-					if collect_all {
+					if collect_all || entry.starts_with(last) {
 						list << append_separator_if_dir(entry)
-					} else {
-						if entry.starts_with(last) {
-							list << append_separator_if_dir(entry)
-						}
 					}
 				}
 			}
 		}
 	}
+	if do_home_expand {
+		return list.map(it.replace_once(os.home_dir().trim_right(os.path_separator), '~'))
+	}
 	return list
 }
 
+fn setup_for_shell(shell string) string {
+	mut setup := ''
+	match shell {
+		'bash' {
+			setup = '
+_v_completions() {
+	local src
+	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}))
+	if [[ \$? == 0 ]]; then
+		eval \${src}
+		#echo \${src}
+	fi
+}
+
+complete -o nospace -F _v_completions v
+'
+		}
+		'fish' {
+			setup = '
+function __v_completions
+	# Send all words up to the one before the cursor
+	$vexe complete fish (commandline -cop)
+end
+complete -f -c v -a "(__v_completions)"
+'
+		}
+		'zsh' {
+			setup = '
+#compdef v
+_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]}))
+	if [[ \$? == 0 ]]; then
+		eval \${src}
+		#echo \${src}
+	fi
+}
+compdef _v v
+'
+		}
+		'powershell' {
+			setup = '
+Register-ArgumentCompleter -Native -CommandName v -ScriptBlock {
+	param(\$commandName, \$wordToComplete, \$cursorPosition)
+		$vexe complete powershell "\$wordToComplete" | ForEach-Object {
+			[System.Management.Automation.CompletionResult]::new(\$_, \$_, \'ParameterValue\', \$_)
+		}
+}
+'
+		}
+		else {}
+	}
+	return setup
+}
+
 fn main() {
 	args := os.args[1..]
 	// println('"$args"')

cmd/tools/vcompress.v

@@ -0,0 +1,44 @@
+module main
+
+import compress.zlib
+import os
+
+enum CompressionType {
+	zlib
+}
+
+fn main() {
+	if os.args.len != 5 {
+		eprintln('v compress <type> <in> <out>')
+		eprintln('supported types: zlib')
+		exit(1)
+	}
+	compression_type := match os.args[2] {
+		'zlib' {
+			CompressionType.zlib
+		}
+		else {
+			eprintln('unsupported type: ${os.args[1]}')
+			exit(1)
+		}
+	}
+	path := os.args[3]
+	content := os.read_bytes(path) or {
+		eprintln('unable to read "$path": $err')
+		exit(1)
+	}
+	compressed := match compression_type {
+		.zlib {
+			zlib.compress(content) or {
+				eprintln('compression error: $err')
+				exit(1)
+			}
+		}
+	}
+	out_path := os.args[4]
+
+	os.write_file_array(out_path, compressed) or {
+		eprintln('failed to write "$out_path": $err')
+		exit(1)
+	}
+}

cmd/tools/vcreate.v

@@ -1,4 +1,4 @@
-// Copyright (c) 2019-2021 Alexander Medvednikov. All rights reserved.
+// Copyright (c) 2019-2022 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
 
@@ -42,50 +42,62 @@ fn check_name(name string) string {
 }
 
 fn vmod_content(c Create) string {
-	return [
-		'Module {',
-		"	name: '$c.name'",
-		"	description: '$c.description'",
-		"	version: '$c.version'",
-		"	license: '$c.license'",
-		'	dependencies: []',
-		'}',
-		'',
-	].join('\n')
+	return "Module {
+	name: '$c.name'
+	description: '$c.description'
+	version: '$c.version'
+	license: '$c.license'
+	dependencies: []
+}
+"
 }
 
 fn main_content() string {
-	return [
-		'module main\n',
-		'fn main() {',
-		"	println('Hello World!')",
-		'}',
-		'',
-	].join('\n')
+	return "module main
+
+fn main() {
+	println('Hello World!')
+}
+"
 }
 
 fn gen_gitignore(name string) string {
-	return [
-		'# Binaries for programs and plugins',
-		'main',
-		'$name',
-		'*.exe',
-		'*.exe~',
-		'*.so',
-		'*.dylib',
-		'*.dll',
-		'',
-	].join('\n')
+	return '# Binaries for programs and plugins
+main
+$name
+*.exe
+*.exe~
+*.so
+*.dylib
+*.dll
+vls.log
+'
+}
+
+fn gitattributes_content() string {
+	return '*.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
+'
+}
+
+fn editorconfig_content() string {
+	return '[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.v]
+indent_style = tab
+indent_size = 4
+'
 }
 
 fn (c &Create) write_vmod(new bool) {
 	vmod_path := if new { '$c.name/v.mod' } else { 'v.mod' }
-	mut vmod := os.create(vmod_path) or {
-		cerror(err.msg)
-		exit(1)
-	}
-	vmod.write_string(vmod_content(c)) or { panic(err) }
-	vmod.close()
+	os.write_file(vmod_path, vmod_content(c)) or { panic(err) }
 }
 
 fn (c &Create) write_main(new bool) {
@@ -93,12 +105,23 @@ fn (c &Create) write_main(new bool) {
 		return
 	}
 	main_path := if new { '$c.name/${c.name}.v' } else { '${c.name}.v' }
-	mut mainfile := os.create(main_path) or {
-		cerror(err.msg)
-		exit(2)
+	os.write_file(main_path, main_content()) or { panic(err) }
+}
+
+fn (c &Create) write_gitattributes(new bool) {
+	gitattributes_path := if new { '$c.name/.gitattributes' } else { '.gitattributes' }
+	if !new && os.exists(gitattributes_path) {
+		return
 	}
-	mainfile.write_string(main_content()) or { panic(err) }
-	mainfile.close()
+	os.write_file(gitattributes_path, gitattributes_content()) or { panic(err) }
+}
+
+fn (c &Create) write_editorconfig(new bool) {
+	editorconfig_path := if new { '$c.name/.editorconfig' } else { '.editorconfig' }
+	if !new && os.exists(editorconfig_path) {
+		return
+	}
+	os.write_file(editorconfig_path, editorconfig_content()) or { panic(err) }
 }
 
 fn (c &Create) create_git_repo(dir string) {
@@ -110,13 +133,9 @@ fn (c &Create) create_git_repo(dir string) {
 			exit(4)
 		}
 	}
-	if !os.exists('$dir/.gitignore') {
-		mut fl := os.create('$dir/.gitignore') or {
-			// We don't really need a .gitignore, it's just a nice-to-have
-			return
-		}
-		fl.write_string(gen_gitignore(c.name)) or { panic(err) }
-		fl.close()
+	gitignore_path := '$dir/.gitignore'
+	if !os.exists(gitignore_path) {
+		os.write_file(gitignore_path, gen_gitignore(c.name)) or {}
 	}
 }
 
@@ -141,7 +160,7 @@ fn create(args []string) {
 	if c.version == '' {
 		c.version = default_version
 	}
-	default_license := 'MIT'
+	default_license := os.getenv_opt('VLICENSE') or { 'MIT' }
 	c.license = os.input('Input your project license: ($default_license) ')
 	if c.license == '' {
 		c.license = default_license
@@ -150,22 +169,23 @@ fn create(args []string) {
 	os.mkdir(c.name) or { panic(err) }
 	c.write_vmod(true)
 	c.write_main(true)
+	c.write_gitattributes(true)
+	c.write_editorconfig(true)
 	c.create_git_repo(c.name)
 }
 
 fn init_project() {
-	if os.exists('v.mod') {
-		cerror('`v init` cannot be run on existing v modules')
-		exit(3)
-	}
 	mut c := Create{}
 	c.name = check_name(os.file_name(os.getwd()))
-	c.description = ''
-	c.write_vmod(false)
+	if !os.exists('v.mod') {
+		c.description = ''
+		c.write_vmod(false)
+		println('Change the description of your project in `v.mod`')
+	}
 	c.write_main(false)
+	c.write_gitattributes(false)
+	c.write_editorconfig(false)
 	c.create_git_repo('.')
-
-	println('Change the description of your project in `v.mod`')
 }
 
 fn main() {

cmd/tools/vcreate_test.v

@@ -1,20 +1,19 @@
 import os
 
-const test_path = 'vcreate_test'
+const test_path = os.join_path(os.temp_dir(), 'v', 'vcreate_test')
 
-fn init_and_check() ? {
-	vexe := @VEXE
-	os.execute_or_exit('$vexe init')
+fn init_and_check() ! {
+	os.execute_or_exit('${os.quoted_path(@VEXE)} init')
 
-	assert os.read_file('vcreate_test.v') ? == [
+	assert os.read_file('vcreate_test.v')! == [
 		'module main\n',
 		'fn main() {',
 		"	println('Hello World!')",
 		'}',
 		'',
-	].join('\n')
+	].join_lines()
 
-	assert os.read_file('v.mod') ? == [
+	assert os.read_file('v.mod')! == [
 		'Module {',
 		"	name: 'vcreate_test'",
 		"	description: ''",
@@ -23,9 +22,9 @@ fn init_and_check() ? {
 		'	dependencies: []',
 		'}',
 		'',
-	].join('\n')
+	].join_lines()
 
-	assert os.read_file('.gitignore') ? == [
+	assert os.read_file('.gitignore')! == [
 		'# Binaries for programs and plugins',
 		'main',
 		'vcreate_test',
@@ -34,46 +33,77 @@ fn init_and_check() ? {
 		'*.so',
 		'*.dylib',
 		'*.dll',
+		'vls.log',
 		'',
-	].join('\n')
+	].join_lines()
+
+	assert os.read_file('.gitattributes')! == [
+		'*.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',
+		'',
+	].join_lines()
+
+	assert os.read_file('.editorconfig')! == [
+		'[*]',
+		'charset = utf-8',
+		'end_of_line = lf',
+		'insert_final_newline = true',
+		'trim_trailing_whitespace = true',
+		'',
+		'[*.v]',
+		'indent_style = tab',
+		'indent_size = 4',
+		'',
+	].join_lines()
 }
 
-fn test_v_init() ? {
-	dir := os.join_path(os.temp_dir(), test_path)
-	os.rmdir_all(dir) or {}
-	os.mkdir(dir) or {}
-	defer {
-		os.rmdir_all(dir) or {}
-	}
-	os.chdir(dir)
-
-	init_and_check() ?
+fn prepare_test_path() ! {
+	os.rmdir_all(test_path) or {}
+	os.mkdir_all(test_path) or {}
+	os.chdir(test_path)!
 }
 
-fn test_v_init_in_git_dir() ? {
-	dir := os.join_path(os.temp_dir(), test_path)
-	os.rmdir_all(dir) or {}
-	os.mkdir(dir) or {}
-	defer {
-		os.rmdir_all(dir) or {}
-	}
-	os.chdir(dir)
+fn test_v_init() {
+	prepare_test_path()!
+	init_and_check()!
+}
+
+fn test_v_init_in_git_dir() {
+	prepare_test_path()!
 	os.execute_or_exit('git init .')
-	init_and_check() ?
+	init_and_check()!
 }
 
-fn test_v_init_no_overwrite_gitignore() ? {
-	dir := os.join_path(os.temp_dir(), test_path)
-	os.rmdir_all(dir) or {}
-	os.mkdir(dir) or {}
-	os.write_file('$dir/.gitignore', 'blah') ?
-	defer {
-		os.rmdir_all(dir) or {}
-	}
-	os.chdir(dir)
-
-	vexe := @VEXE
-	os.execute_or_exit('$vexe init')
-
-	assert os.read_file('.gitignore') ? == 'blah'
+fn test_v_init_no_overwrite_gitignore() {
+	prepare_test_path()!
+	os.write_file('.gitignore', 'blah')!
+	os.execute_or_exit('${os.quoted_path(@VEXE)} init')
+	assert os.read_file('.gitignore')! == 'blah'
+}
+
+fn test_v_init_no_overwrite_gitattributes_and_editorconfig() {
+	git_attributes_content := '*.v linguist-language=V text=auto eol=lf'
+	editor_config_content := '[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.v]
+indent_style = tab
+indent_size = 4
+'
+	prepare_test_path()!
+	os.write_file('.gitattributes', git_attributes_content)!
+	os.write_file('.editorconfig', editor_config_content)!
+	os.execute_or_exit('${os.quoted_path(@VEXE)} init')
+
+	assert os.read_file('.gitattributes')! == git_attributes_content
+	assert os.read_file('.editorconfig')! == editor_config_content
+}
+
+fn testsuite_end() {
+	os.rmdir_all(test_path) or {}
 }

cmd/tools/vdoc/html.v

@@ -4,6 +4,7 @@ import os
 import net.urllib
 import strings
 import markdown
+import regex
 import v.scanner
 import v.ast
 import v.token
@@ -11,68 +12,13 @@ import v.doc
 import v.pref
 
 const (
-	css_js_assets = ['doc.css', 'normalize.css', 'doc.js', 'dark-mode.js']
-	res_path      = os.resource_abs_path('resources')
-	favicons_path = os.join_path(res_path, 'favicons')
-	link_svg      = '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"/></svg>'
-	html_content  = '<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8">
-		<meta http-equiv="x-ua-compatible" content="IE=edge" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0">
-		<title>{{ title }} | vdoc</title>
-		<link rel="preconnect" href="https://fonts.gstatic.com">
-		<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700&display=swap" rel="stylesheet">
-		<link href="https://fonts.googleapis.com/css2?family=Work+Sans:wght@400;500;600&display=swap" rel="stylesheet">
-		<link rel="apple-touch-icon" sizes="180x180" href="apple-touch-icon.png">
-		<link rel="icon" type="image/png" sizes="32x32" href="favicon-32x32.png">
-		<link rel="icon" type="image/png" sizes="16x16" href="favicon-16x16.png">
-		<link rel="manifest" href="site.webmanifest">
-		<link rel="mask-icon" href="safari-pinned-tab.svg" color="#5bbad5">
-		<meta name="msapplication-TileColor" content="#da532c">
-		<meta name="theme-color" content="#ffffff">
-		{{ head_assets }}
-	</head>
-	<body>
-		<div id="page">
-			<header class="doc-nav hidden">
-				<div class="heading-container">
-					<div class="heading">
-						<div class="info">
-							<div class="module">{{ head_name }}</div>
-							<div class="toggle-version-container">
-								<span>{{ version }}</span>
-								<div id="dark-mode-toggle" role="switch" aria-checked="false" aria-label="Toggle dark mode">{{ light_icon }}{{ dark_icon }}</div>
-							</div>
-							{{ menu_icon }}
-						</div>
-						<input type="text" id="search" placeholder="Search... (beta)" autocomplete="off">
-					</div>
-				</div>
-				<nav class="search hidden"></nav>
-				<nav class="content hidden">
-					<ul>
-						{{ toc_links }}
-					</ul>
-				</nav>
-			</header>
-			<div class="doc-scrollview">
-				<div class="doc-container">
-					<div class="doc-content">
-{{ contents }}
-						<div class="footer">
-							{{ footer_content }}
-						</div>
-					</div>
-					{{ right_content }}
-				</div>
-			</div>
-		</div>
-		{{ footer_assets }}
-		<script async src="search_index.js" type="text/javascript"></script>
-	</body>
-</html>'
+	css_js_assets         = ['doc.css', 'normalize.css', 'doc.js', 'dark-mode.js']
+	default_theme         = os.resource_abs_path('theme')
+	link_svg              = '<svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"/></svg>'
+
+	single_quote          = "'"
+	double_quote          = '"'
+	no_quotes_replacement = [single_quote, '', double_quote, '']
 )
 
 enum HighlightTokenTyp {
@@ -133,7 +79,7 @@ fn (vd VDoc) render_search_index(out Output) {
 }
 
 fn (mut vd VDoc) render_static_html(out Output) {
-	vd.assets = map{
+	vd.assets = {
 		'doc_css':       vd.get_resource(css_js_assets[0], out)
 		'normalize_css': vd.get_resource(css_js_assets[1], out)
 		'doc_js':        vd.get_resource(css_js_assets[2], out)
@@ -147,7 +93,7 @@ fn (mut vd VDoc) render_static_html(out Output) {
 
 fn (vd VDoc) get_resource(name string, out Output) string {
 	cfg := vd.cfg
-	path := os.join_path(res_path, name)
+	path := os.join_path(cfg.theme_dir, name)
 	mut res := os.read_file(path) or { panic('vdoc: could not read $path') }
 	/*
 	if minify {
@@ -251,7 +197,8 @@ fn (vd VDoc) gen_html(d doc.Doc) string {
 		write_toc(cn, mut symbols_toc)
 	} // write head
 	// write css
-	version := if vd.manifest.version.len != 0 { vd.manifest.version } else { '' }
+	mut version := if vd.manifest.version.len != 0 { vd.manifest.version } else { '' }
+	version = [version, @VHASH].join(' ')
 	header_name := if cfg.is_multi && vd.docs.len > 1 {
 		os.file_name(os.real_path(cfg.input_path))
 	} else {
@@ -297,8 +244,9 @@ fn (vd VDoc) gen_html(d doc.Doc) string {
 	}
 	modules_toc_str := modules_toc.str()
 	symbols_toc_str := symbols_toc.str()
-	result := html_content.replace('{{ title }}', d.head.name).replace('{{ head_name }}',
-		header_name).replace('{{ version }}', version).replace('{{ light_icon }}', vd.assets['light_icon']).replace('{{ dark_icon }}',
+	result := (os.read_file(os.join_path(cfg.theme_dir, 'index.html')) or { panic(err) }).replace('{{ title }}',
+		d.head.name).replace('{{ head_name }}', header_name).replace('{{ version }}',
+		version).replace('{{ light_icon }}', vd.assets['light_icon']).replace('{{ dark_icon }}',
 		vd.assets['dark_icon']).replace('{{ menu_icon }}', vd.assets['menu_icon']).replace('{{ head_assets }}',
 		if cfg.inline_assets {
 		'\n${tabs[0]}<style>' + vd.assets['doc_css'] + '</style>\n${tabs[0]}<style>' +
@@ -354,6 +302,8 @@ fn html_highlight(code string, tb &ast.Table) string {
 			"'$tok.lit'"
 		} else if typ == .char {
 			'`$tok.lit`'
+		} else if typ == .comment {
+			if tok.lit != '' && tok.lit[0] == 1 { '//${tok.lit[1..]}' } else { '//$tok.lit' }
 		} else {
 			tok.lit
 		}
@@ -376,7 +326,8 @@ fn html_highlight(code string, tb &ast.Table) string {
 						tok_typ = .builtin
 					} else if next_tok.kind == .lcbr {
 						tok_typ = .symbol
-					} else if next_tok.kind == .lpar {
+					} else if next_tok.kind == .lpar || (!tok.lit[0].is_capital()
+						&& next_tok.kind == .lt && next_tok.pos == tok.pos + tok.lit.len) {
 						tok_typ = .function
 					} else {
 						tok_typ = .name
@@ -397,14 +348,15 @@ fn html_highlight(code string, tb &ast.Table) string {
 				.key_true, .key_false {
 					tok_typ = .boolean
 				}
-				.lpar, .lcbr, .rpar, .rcbr, .lsbr, .rsbr, .semicolon, .colon, .comma, .dot {
+				.lpar, .lcbr, .rpar, .rcbr, .lsbr, .rsbr, .semicolon, .colon, .comma, .dot,
+				.dotdot, .ellipsis {
 					tok_typ = .punctuation
 				}
 				else {
 					if token.is_key(tok.lit) || token.is_decl(tok.kind) {
 						tok_typ = .keyword
 					} else if tok.kind == .decl_assign || tok.kind.is_assign() || tok.is_unary()
-						|| tok.kind.is_relational() || tok.kind.is_infix() {
+						|| tok.kind.is_relational() || tok.kind.is_infix() || tok.kind.is_postfix() {
 						tok_typ = .operator
 					}
 				}
@@ -418,7 +370,7 @@ fn html_highlight(code string, tb &ast.Table) string {
 				break
 			}
 		} else {
-			buf.write_b(code[i])
+			buf.write_u8(code[i])
 			i++
 		}
 	}
@@ -441,8 +393,9 @@ fn doc_node_html(dn doc.DocNode, link string, head bool, include_examples bool,
 	highlighted_code := html_highlight(dn.content, tb)
 	node_class := if dn.kind == .const_group { ' const' } else { '' }
 	sym_name := get_sym_name(dn)
-	has_deprecated := 'deprecated' in dn.tags
-	mut tags := dn.tags.filter(it != 'deprecated')
+	mut deprecated_tags := dn.tags.filter(it.starts_with('deprecated'))
+	deprecated_tags.sort()
+	mut tags := dn.tags.filter(!it.starts_with('deprecated'))
 	tags.sort()
 	mut node_id := get_node_id(dn)
 	mut hash_link := if !head { ' <a href="#$node_id">#</a>' } else { '' }
@@ -462,13 +415,12 @@ fn doc_node_html(dn doc.DocNode, link string, head bool, include_examples bool,
 		}
 		dnw.write_string('</div>')
 	}
-	if tags.len > 0 || has_deprecated {
-		mut attributes := if has_deprecated {
-			'<div class="attribute attribute-deprecated">deprecated</div>'
-		} else {
-			''
-		}
-		attributes += tags.map('<div class="attribute">$it</div>').join('')
+	if deprecated_tags.len > 0 {
+		attributes := deprecated_tags.map('<div class="attribute attribute-deprecated">${no_quotes(it)}</div>').join('')
+		dnw.writeln('<div class="attributes">$attributes</div>')
+	}
+	if tags.len > 0 {
+		attributes := tags.map('<div class="attribute">$it</div>').join('')
 		dnw.writeln('<div class="attributes">$attributes</div>')
 	}
 	if !head && dn.content.len > 0 {
@@ -482,8 +434,8 @@ fn doc_node_html(dn doc.DocNode, link string, head bool, include_examples bool,
 		example_title := if examples.len > 1 { 'Examples' } else { 'Example' }
 		dnw.writeln('<section class="doc-node examples"><h4>$example_title</h4>')
 		for example in examples {
-			// hl_example := html_highlight(example, tb)
-			dnw.writeln('<pre><code class="language-v">$example</code></pre>')
+			hl_example := html_highlight(example, tb)
+			dnw.writeln('<pre><code class="language-v">$hl_example</code></pre>')
 		}
 		dnw.writeln('</section>')
 	}
@@ -493,7 +445,12 @@ fn doc_node_html(dn doc.DocNode, link string, head bool, include_examples bool,
 }
 
 fn html_tag_escape(str string) string {
-	return str.replace_each(['<', '&lt;', '>', '&gt;'])
+	excaped_string := str.replace_each(['<', '&lt;', '>', '&gt;'])
+	mut re := regex.regex_opt(r'`.+[(&lt;)(&gt;)].+`') or { regex.RE{} }
+	if re.find_all_str(excaped_string).len > 0 {
+		return str
+	}
+	return excaped_string
 }
 
 /*
@@ -545,3 +502,7 @@ fn write_toc(dn doc.DocNode, mut toc strings.Builder) {
 	}
 	toc.writeln('</li>')
 }
+
+fn no_quotes(s string) string {
+	return s.replace_each(no_quotes_replacement)
+}

cmd/tools/vdoc/html_tag_escape_test.v

@@ -0,0 +1,6 @@
+module main
+
+fn test_html_tag_escape() {
+	assert html_tag_escape('<abc>') == '&lt;abc&gt;'
+	assert html_tag_escape('`<abc>`') == '`<abc>`'
+}

cmd/tools/vdoc/markdown.v

@@ -47,7 +47,8 @@ fn (vd VDoc) write_markdown_content(contents []doc.DocNode, mut cw strings.Build
 				}
 				cw.writeln('```\n')
 			}
-			cw.writeln('[\[Return to contents\]](#Contents)\n')
+			cw.writeln(r'[[Return to contents]](#Contents)')
+			cw.writeln('')
 		}
 		vd.write_markdown_content(cn.children, mut cw, mut hw, indent + 1, with_toc)
 	}

cmd/tools/vdoc/tests/testdata/basic/main.comments.out

@@ -0,0 +1,13 @@
+module main
+
+const (
+	source_root = 'temp' // some const
+	another     = int(5) //
+)
+const (
+	windowpos_undefined_mask = C.SDL_WINDOWPOS_UNDEFINED_MASK //   0x1FFF0000u
+	windowpos_undefined      = C.SDL_WINDOWPOS_UNDEFINED //
+)
+    Used to indicate that you don't care what the window position is.
+fn funky()
+    funky - comment for function below

cmd/tools/vdoc/tests/testdata/basic/main.out

@@ -0,0 +1,11 @@
+module main
+
+const (
+	source_root = 'temp' // some const
+	another     = int(5) //
+)
+const (
+	windowpos_undefined_mask = C.SDL_WINDOWPOS_UNDEFINED_MASK //   0x1FFF0000u
+	windowpos_undefined      = C.SDL_WINDOWPOS_UNDEFINED //
+)
+fn funky()

cmd/tools/vdoc/tests/testdata/basic/main.v

@@ -0,0 +1,15 @@
+pub const (
+	source_root = 'temp' // some const
+	another     = int(5) //
+)
+
+// Used to indicate that you don't care what the window position is.
+pub const (
+	windowpos_undefined_mask = C.SDL_WINDOWPOS_UNDEFINED_MASK //   0x1FFF0000u
+	windowpos_undefined      = C.SDL_WINDOWPOS_UNDEFINED //
+)
+
+// funky - comment for function below
+pub fn funky() {
+	println('hi')
+}

cmd/tools/vdoc/tests/testdata/multiline/main.comments.out

@@ -0,0 +1,9 @@
+module main
+
+fn a1()
+    normal comment
+fn a2()
+    this should be merged into the same line
+fn a3()
+    This should be its own parapgraph, because it ends with a dot.  
+    This should be another paragraph.

cmd/tools/vdoc/tests/testdata/multiline/main.out

@@ -0,0 +1,5 @@
+module main
+
+fn a1()
+fn a2()
+fn a3()

cmd/tools/vdoc/tests/testdata/multiline/main.v

@@ -0,0 +1,16 @@
+// normal comment
+pub fn a1() {
+	println('hi')
+}
+
+// this should be merged
+// into the same line
+pub fn a2() {
+	println('hi')
+}
+
+// This should be its own parapgraph, because it ends with a dot.
+// This should be another paragraph.
+pub fn a3() {
+	println('hi')
+}

cmd/tools/vdoc/tests/testdata/newlines/main.comments.out

@@ -0,0 +1,22 @@
+module main
+
+fn funky()
+    hello
+    
+    empty line
+    newline using a full stop.  
+    ```v
+    code
+    ```
+    
+    test
+    ====
+    - foo
+    - bar
+    # test
+    ########### deep test
+    #a shouldnt have a newline test
+    
+    | foo bar   |  yes   |
+    |-----------|--------|
+    |  working  |  yup   |

cmd/tools/vdoc/tests/testdata/newlines/main.out

@@ -0,0 +1,3 @@
+module main
+
+fn funky()

cmd/tools/vdoc/tests/testdata/newlines/main.v

@@ -0,0 +1,23 @@
+// hello
+//
+// empty line
+// newline using a full stop.
+// ```v
+// code
+// ```
+//
+// test
+// ====
+// - foo
+// - bar
+// # test
+// ########### deep test
+// #a shouldnt have a newline
+// test
+//
+// | foo bar   |  yes   |
+// |-----------|--------|
+// |  working  |  yup   |
+pub fn funky() {
+	println('hi')
+}

cmd/tools/vdoc/tests/testdata/project1/main.out

@@ -1 +0,0 @@
-vdoc: No documentation found for /v/vmaster/cmd/tools/vdoc/tests/testdata/project1/main.v

cmd/tools/vdoc/tests/testdata/project1/main.v

@@ -1,8 +0,0 @@
-const (
-	source_root = 'temp'
-)
-
-// funky - comment for function below
-fn funky() {
-	println('hi')
-}

cmd/tools/vdoc/tests/vdoc_file_test.v

@@ -16,7 +16,7 @@ fn find_diff_cmd() string {
 
 fn test_vet() {
 	os.setenv('VCOLORS', 'never', true)
-	os.chdir(vroot)
+	os.chdir(vroot)!
 	test_dir := 'cmd/tools/vdoc/tests/testdata'
 	main_files := get_main_files_in_dir(test_dir)
 	fails := check_path(vexe, test_dir, main_files)
@@ -35,7 +35,7 @@ fn check_path(vexe string, dir string, tests []string) int {
 	for path in paths {
 		program := path
 		print(path + ' ')
-		res := os.execute('$vexe doc $program')
+		res := os.execute('${os.quoted_path(vexe)} doc ${os.quoted_path(program)}')
 		if res.exit_code < 0 {
 			panic(res.output)
 		}
@@ -43,25 +43,45 @@ fn check_path(vexe string, dir string, tests []string) int {
 		expected = clean_line_endings(expected)
 		found := clean_line_endings(res.output)
 		if expected != found {
-			println(term.red('FAIL'))
-			println('============')
-			println('expected:')
-			println(expected)
-			println('============')
-			println('found:')
-			println(found)
-			println('============\n')
-			println('diff:')
-			println(diff.color_compare_strings(diff_cmd, rand.ulid(), found, expected))
-			println('============\n')
-			nb_fail++
-		} else {
+			print_compare(expected, found)
+		}
+
+		res_comments := os.execute('${os.quoted_path(vexe)} doc -comments ${os.quoted_path(program)}')
+		if res_comments.exit_code < 0 {
+			panic(res_comments.output)
+		}
+		mut expected_comments := os.read_file(program.replace('main.v', 'main.comments.out')) or {
+			panic(err)
+		}
+		expected_comments = clean_line_endings(expected_comments)
+		found_comments := clean_line_endings(res_comments.output)
+		if expected_comments != found_comments {
+			print_compare(expected_comments, found_comments)
+		}
+
+		if expected == found && expected_comments == found_comments {
 			println(term.green('OK'))
+		} else {
+			nb_fail++
 		}
 	}
 	return nb_fail
 }
 
+fn print_compare(expected string, found string) {
+	println(term.red('FAIL'))
+	println('============')
+	println('expected:')
+	println(expected)
+	println('============')
+	println('found:')
+	println(found)
+	println('============\n')
+	println('diff:')
+	println(diff.color_compare_strings(diff_cmd, rand.ulid(), found, expected))
+	println('============\n')
+}
+
 fn clean_line_endings(s string) string {
 	mut res := s.trim_space()
 	res = res.replace(' \n', '\n')