switch on

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -7,16 +7,17 @@ body:
 - type: markdown
   attributes:
     value: |
-      Please provide a minimal code example that reproduces the bug if possible.
-      Reports with a reproducible example or detailed information will likely receive fixes faster.
+      - **Please provide a minimal code example that reproduces the Bug!** :bug:
+        Reports with a reproducible example and descriptive detailed information will likely receive fixes faster.
 
 - type: textarea
   id: description
   attributes:
     label: Description
     description: |
-      Describe the problem. Code example can be given here.
-    placeholder: Bug reports with reproducible code or detailed information will be fixed faster.
+      Use DETAILED DESCRIPTIVE information about the problem.
+      Here, you go into more details about your Bug report. This section can be a few paragraphs long.
+    placeholder: Bug reports with reproducible code and detailed information will be fixed faster.
   validations:
     required: true
     
@@ -24,9 +25,7 @@ body:
   id: nim-version
   attributes:
     label: Nim Version
-    description: |
-      Can be obtained from `nim -v` on the command line along with the OS/architecture.
-      For development versions, make sure to include the commit hash.
+    description: Copy and paste the output of `nim -v` on the command line. For development versions, make sure to include the commit hash.
   validations:
     required: true
 
@@ -35,7 +34,7 @@ body:
   attributes:
     label: Current Output
     description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-    placeholder: Bug reports with reproducible code or detailed information will be fixed faster.
+    placeholder: Bug reports with reproducible code and detailed information will be fixed faster.
     render: text
 
 - type: textarea
@@ -43,14 +42,14 @@ body:
   attributes:
     label: Expected Output
     description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-    placeholder: Bug reports with reproducible code or detailed information will be fixed faster.
+    placeholder: Bug reports with reproducible code and detailed information will be fixed faster.
     render: text
 
 - type: textarea
-  id: known-workarounds
+  id: possible-solution
   attributes:
-    label: Known Workarounds
-    description: Provide any known workarounds.
+    label: Possible Solution
+    description: Propose a possible solution.
   validations:
     required: false
 
@@ -65,9 +64,13 @@ body:
 - type: markdown
   attributes:
     value: |
-      - Please check whether the problem still exists in the devel branch, which can be installed via [choosenim](https://github.com/nim-lang/choosenim/), [nightlies](https://github.com/nim-lang/nightlies/), or by [creating a temporary build of the compiler](https://nim-lang.github.io/Nim/intern.html#debugging-the-compiler-building-an-instrumented-compiler).
+      - Thanks for your contributions!, your Bug report will receive feedback from the community soon...
+      - Please check whether the problem still exists in the devel branch, see [rebuilding the compiler](https://nim-lang.github.io/Nim/intern.html#rebuilding-the-compiler).
       - Consider writing a PR targetting devel branch after filing this, see [contributing](https://nim-lang.github.io/Nim/contributing.html).
-      - If it's a pre-existing compiler bug, see [debugging the compiler](https://nim-lang.github.io/Nim/intern.html#debugging-the-compiler) which should give more context on a compiler crash.
-      - If it's a regression, you can help us by identifying which version introduced the bug by [bisecting](https://nim-lang.github.io/Nim/intern.html#bisecting-for-regressions) or at least trying known past releases (e.g. `choosenim 2.0.0`).
-        The Nim repo also supports bisecting in issue comments by adding `!nim c`, `!nim js` etc. before a code block, see [nimrun-action](https://github.com/juancarlospaco/nimrun-action).
+      - If it's a pre-existing compiler bug, see [Debugging the compiler](https://nim-lang.github.io/Nim/intern.html#debugging-the-compiler)
+        which should give more context on a compiler crash.
+      - If it's a regression, you can help us by identifying which version introduced the bug,
+        see [Bisecting for regressions](https://nim-lang.github.io/Nim/intern.html#bisecting-for-regressions),
+        or at least try known past releases (e.g. `choosenim 2.0.0`). The Nim repo also supports online bisecting
+        via making a comment, which contains a code block starting by `!nim c`, `!nim js` etc. , see [nimrun-action](https://github.com/juancarlospaco/nimrun-action).
       - [Please, consider a Donation for the Nim project.](https://nim-lang.org/donate.html)

.github/workflows/ci_bench.yml

@@ -0,0 +1,115 @@
+name: Benchmarks CI
+on:
+  pull_request:
+  push:
+    branches:
+      - 'devel'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04]
+        cpu: [amd64]
+    name: '${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60 # refs bug #18178
+    steps:
+      - name: 'Checkout'
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: 'Install node.js 20.x'
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20.x'
+
+      - name: 'Install dependencies (Linux amd64)'
+        if: runner.os == 'Linux' && matrix.cpu == 'amd64'
+        run: |
+          sudo apt-fast update -qq
+          DEBIAN_FRONTEND='noninteractive' \
+            sudo apt-fast install --no-install-recommends -yq \
+              libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev \
+              valgrind libc6-dbg libblas-dev xorg-dev
+
+      - name: 'Add build binaries to PATH'
+        shell: bash
+        run: echo "${{ github.workspace }}/bin" >> "${GITHUB_PATH}"
+
+      - name: 'Build csourcesAny'
+        shell: bash
+        run: . ci/funs.sh && nimBuildCsourcesIfNeeded CC=gcc ucpu='${{ matrix.cpu }}'
+
+      - name: 'Build koch'
+        shell: bash
+        run: nim c koch
+
+      - name: 'Build Nim'
+        shell: bash
+        run: ./koch boot -d:release -d:nimStrictMode --lib:lib
+
+      - name: 'Build Nimble'
+        shell: bash
+        run: ./koch nimble
+
+      - name: 'Action'
+        shell: bash
+        run: nim c -r -d:release ci/action.nim
+
+      - name: 'Checkout minimize'
+        uses: actions/checkout@v4
+        with:
+          repository: 'nim-lang/ci_bench'
+          path: minimize
+
+      - name: 'Run minimize benchmarks'
+        shell: bash
+        run: ./minimize/minimize ci-bench
+
+      - name: 'Restore minimize cached database'
+        uses: actions/cache/restore@v3
+        with:
+          path: minimize.csv
+          key: minimize-db-key
+
+      - name: 'Update minimize db'
+        shell: bash
+        run: ./minimize/minimize update-db
+
+      - name: 'Save minimize cached database'
+        if: |
+          github.event_name == 'push' && github.ref == 'refs/heads/devel' &&
+          matrix.target == 'linux'
+        uses: actions/cache/save@v3
+        with:
+          path: minimize.csv
+          key: minimize-db-key
+
+      - name: 'Generate minimize report'
+        shell: bash
+        run: ./minimize/minimize generate-report
+
+      - name: 'Archive minimize report'
+        uses: actions/upload-artifact@v3
+        with:
+          name: minimize-report
+          path: |
+            minimize/minimize.html
+            minimize/minimize.csv
+
+      # Requires additional permissions, see:
+      # https://github.com/nim-lang/Nim/actions/runs/4778177321/jobs/8494423792?pr=21566
+      # - name: 'Publish HTML report'
+      #   uses: rossjrw/pr-preview-action@v1
+      #   with:
+      #     source-dir: minimize
+      #     umbrella-dir: minimize
+      #   env:
+      #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract md summary
+        run: |
+          cat minimize/summary.md  >> $GITHUB_STEP_SUMMARY

.github/workflows/ci_docs.yml

@@ -45,7 +45,7 @@ jobs:
           - target: windows
             os: windows-2019
           - target: osx
-            os: macos-13
+            os: macos-11
 
     name: ${{ matrix.target }}
     runs-on: ${{ matrix.os }}
@@ -109,7 +109,7 @@ jobs:
         if: |
           github.event_name == 'push' && github.ref == 'refs/heads/devel' &&
           matrix.target == 'linux'
-        uses: crazy-max/ghaction-github-pages@v4
+        uses: crazy-max/ghaction-github-pages@v3
         with:
           build_dir: doc/html
         env:

.github/workflows/ci_packages.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches:
       - 'devel'
-      - 'version-2-2'
       - 'version-2-0'
       - 'version-1-6'
       - 'version-1-2'
@@ -18,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-13]
+        os: [ubuntu-20.04, macos-11]
         cpu: [amd64]
         batch: ["allowed_failures", "0_3", "1_3", "2_3"] # list of `index_num`
     name: '${{ matrix.os }} (batch: ${{ matrix.batch }})'
@@ -49,7 +48,6 @@ jobs:
       - name: 'Install dependencies (macOS)'
         if: runner.os == 'macOS'
         run: brew install boehmgc make sfml gtk+3
-        # XXX can't find boehm and gtk on macos 13
       - name: 'Install dependencies (Windows)'
         if: runner.os == 'Windows'
         shell: bash

.github/workflows/ci_publish.yml

@@ -71,7 +71,7 @@ jobs:
         run: nim c -r -d:release ci/action.nim
 
       - name: 'Comment'
-        uses: actions/github-script@v7
+        uses: actions/github-script@v6
         with:
           script: |
             const fs = require('fs');

.github/workflows/stale.yml

@@ -9,7 +9,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v8
         with:
           days-before-pr-stale:    365
           days-before-pr-close:    30

azure-pipelines.yml

@@ -20,7 +20,7 @@ jobs:
   strategy:
     matrix:
       Linux_amd64:
-        vmImage: 'ubuntu-24.04'
+        vmImage: 'ubuntu-20.04'
         CPU: amd64
       # regularly breaks, refs bug #17325
 #       Linux_i386:
@@ -29,10 +29,10 @@ jobs:
 #         vmImage: 'ubuntu-18.04'
 #         CPU: i386
       OSX_amd64:
-        vmImage: 'macOS-13'
+        vmImage: 'macOS-11'
         CPU: amd64
       OSX_amd64_cpp:
-        vmImage: 'macOS-13'
+        vmImage: 'macOS-11'
         CPU: amd64
         NIM_COMPILE_TO_CPP: true
       Windows_amd64_batch0_3:
@@ -80,12 +80,10 @@ jobs:
     - bash: |
         set -e
         . ci/funs.sh
-        echo_run sudo add-apt-repository universe
-        echo_run sudo apt-get update -qq
+        echo_run sudo apt-fast update -qq
         DEBIAN_FRONTEND='noninteractive' \
-          echo_run sudo apt-get install --no-install-recommends -yq \
-            gcc-14 g++-14 libpcre3 liblapack-dev libpcre3 liblapack-dev libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev valgrind libc6-dbg
-        echo_run sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 60 --slave /usr/bin/g++ g++ /usr/bin/g++-14
+          echo_run sudo apt-fast install --no-install-recommends -yq \
+            libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev valgrind libc6-dbg
       displayName: 'Install dependencies (amd64 Linux)'
       condition: and(succeeded(), eq(variables['skipci'], 'false'), eq(variables['Agent.OS'], 'Linux'), eq(variables['CPU'], 'amd64'))
 
@@ -102,16 +100,15 @@ jobs:
         Pin-Priority: 1001
         EOF
 
-        # echo_run sudo apt-get update -qq
-        echo_run sudo apt-get update -qq || echo "failed, see bug #17343"
+        # echo_run sudo apt-fast update -qq
+        echo_run sudo apt-fast update -qq || echo "failed, see bug #17343"
         # `:i386` (e.g. in `libffi-dev:i386`) is needed otherwise you may get:
         # `could not load: libffi.so` during dynamic loading.
         DEBIAN_FRONTEND='noninteractive' \
-          echo_run sudo apt-get install --no-install-recommends --allow-downgrades -yq \
+          echo_run sudo apt-fast install --no-install-recommends --allow-downgrades -yq \
             g++-multilib gcc-multilib libcurl4-openssl-dev:i386 libgc-dev:i386 \
             libsdl1.2-dev:i386 libsfml-dev:i386 libglib2.0-dev:i386 libffi-dev:i386
 
-
         cat << EOF > bin/gcc
         #!/bin/bash
 
@@ -133,7 +130,6 @@ jobs:
     - bash: brew install boehmgc make sfml
       displayName: 'Install dependencies (OSX)'
       condition: and(succeeded(), eq(variables['skipci'], 'false'), eq(variables['Agent.OS'], 'Darwin'))
-      # XXX can't find boehm on macos 13
 
     - bash: |
         set -e

build_all.bat

@@ -24,6 +24,6 @@ if not exist %nim_csources% (
   cd ..
   copy /y bin\nim.exe  %nim_csources%
 )
-bin\nim.exe c --noNimblePath --skipUserCfg --skipParentCfg --hints:off koch
-koch boot -d:release --skipUserCfg --skipParentCfg --hints:off
-koch tools --skipUserCfg --skipParentCfg --hints:off
+ bin\nim.exe c --noNimblePath --skipUserCfg --skipParentCfg --hints:off koch
+ koch boot -d:release --skipUserCfg --skipParentCfg --hints:off
+ koch tools --skipUserCfg --skipParentCfg --hints:off

changelog.md

@@ -1,67 +1,48 @@
-# v2.x.x - yyyy-mm-dd
+# v2.2.0 - yyyy-mm-dd
 
 
 ## Changes affecting backward compatibility
 
-- `-d:nimPreviewFloatRoundtrip` becomes the default. `system.addFloat` and `system.$` now can produce string representations of
-floating point numbers that are minimal in size and possess round-trip and correct
-rounding guarantees (via the
-[Dragonbox](https://raw.githubusercontent.com/jk-jeon/dragonbox/master/other_files/Dragonbox.pdf) algorithm). Use `-d:nimLegacySprintf` to emulate old behaviors.
-
-- The `default` parameter of `tables.getOrDefault` has been renamed to `def` to
-  avoid conflicts with `system.default`, so named argument usage for this
-  parameter like `getOrDefault(..., default = ...)` will have to be changed.
+- `-d:nimStrictDelete` becomes the default. An index error is produced when the index passed to `system.delete` was out of bounds. Use `-d:nimAuditDelete` to mimic the old behavior for backwards compatibility.
+- The default user-agent in `std/httpclient` has been changed to `Nim-httpclient/<version>` instead of `Nim httpclient/<version>` which was incorrect according to the HTTP spec.
+- Methods now support implementations based on a VTable by using `--experimental:vtables`. Methods are then confined to be in the same module where their type has been defined.
+- With `-d:nimPreviewNonVarDestructor`, non-var destructors become the default.
 
 ## Standard library additions and changes
 
-[//]: # "Additions:"
-- `setutils.symmetricDifference` along with its operator version
-  `` setutils.`-+-` `` and in-place version `setutils.toggle` have been added
-  to more efficiently calculate the symmetric difference of bitsets.
-
 [//]: # "Changes:"
-- `std/math` The `^` symbol now supports floating-point as exponent in addition to the Natural type.
+
+- Changed `std/osfiles.copyFile` to allow to specify `bufferSize` instead of a hardcoded one.
+- Changed `std/osfiles.copyFile` to use `POSIX_FADV_SEQUENTIAL` hints for kernel-level aggressive sequential read-aheads.
+- `std/htmlparser` has been moved to a nimble package, use `nimble` or `atlas` to install it.
+
+[//]: # "Additions:"
+
+- Added `newStringUninit` to system, which creates a new string of length `len` like `newString` but with uninitialized content.
+- Added `setLenUninit` to system, which doesn't initalize
+slots when enlarging a sequence.
+- Added `hasDefaultValue` to `std/typetraits` to check if a type has a valid default value.
+- Added Viewport API for the JavaScript targets in the `dom` module.
+
+[//]: # "Deprecations:"
+
+- Deprecates `system.newSeqUninitialized`, which is replaced by `newSeqUninit`.
+
+[//]: # "Removals:"
+
 
 ## Language changes
 
-- An experimental option `--experimental:typeBoundOps` has been added that
-  implements the RFC https://github.com/nim-lang/RFCs/issues/380.
-  This makes the behavior of interfaces like `hash`, `$`, `==` etc. more
-  reliable for nominal types across indirect/restricted imports.
-
-  ```nim
-  # objs.nim
-  import std/hashes
-
-  type
-    Obj* = object
-      x*, y*: int
-      z*: string # to be ignored for equality
-
-  proc `==`*(a, b: Obj): bool =
-    a.x == b.x and a.y == b.y
-
-  proc hash*(a: Obj): Hash =
-    $!(hash(a.x) &! hash(a.y))
-  ```
-
-  ```nim
-  # main.nim
-  {.experimental: "typeBoundOps".}
-  from objs import Obj # objs.hash, objs.`==` not imported
-  import std/tables
-
-  var t: Table[Obj, int]
-  t[Obj(x: 3, y: 4, z: "debug")] = 34
-  echo t[Obj(x: 3, y: 4, z: "ignored")] # 34
-  ```
-
-  See the [experimental manual](https://nim-lang.github.io/Nim/manual_experimental.html#typeminusbound-overloads)
-  for more information.
+- `noInit` can be used in types and fields to disable member initializers in the C++ backend. 
+- C++ custom constructors initializers see https://nim-lang.org/docs/manual_experimental.htm#constructor-initializer
+- `member` can be used to attach a procedure to a C++ type.
+- C++ `constructor` now reuses `result` instead creating `this`.
 
 ## Compiler changes
 
+- `--nimcache` using a relative path as the argument in a config file is now relative to the config file instead of the current directory.
 
 ## Tool changes
 
+- koch now allows bootstrapping with `-d:nimHasLibFFI`, replacing the older option of building the compiler directly w/ the `libffi` nimble package in tow.
 

changelogs/changelog_2_0_0_details.md

@@ -72,7 +72,7 @@
 - `shallowCopy` and `shallow` are removed for ARC/ORC. Use `move` when possible or combine assignment and
 `sink` for optimization purposes.
 
-- The experimental `nimPreviewDotLikeOps` switch is going to be removed or deprecated because it didn't fulfill its promises.
+- The experimental `nimPreviewDotLikeOps` switch is going to be removed or deprecated because it didn't fullfill its promises.
 
 - The `{.this.}` pragma, deprecated since 0.19, has been removed.
 - `nil` literals can no longer be directly assigned to variables or fields of `distinct` pointer types. They must be converted instead.

changelogs/changelog_2_2_0.md

@@ -1,248 +1,12 @@
-# v2.2.0 - 2024-10-02
-
+# v2.2.0 - 2023-mm-dd
 
 ## Changes affecting backward compatibility
 
-- `-d:nimStrictDelete` becomes the default. An index error is produced when the index passed to `system.delete` is out of bounds. Use `-d:nimAuditDelete` to mimic the old behavior for backward compatibility.
-
-- The default user-agent in `std/httpclient` has been changed to `Nim-httpclient/<version>` instead of `Nim httpclient/<version>` which was incorrect according to the HTTP spec.
-
-- Methods now support implementations based on a VTable by using `--experimental:vtables`. Methods are then confined to the same module where their type has been defined.
-
-- With `-d:nimPreviewNonVarDestructor`, non-var destructors become the default.
-
-- A bug where tuple unpacking assignment with a longer tuple on the RHS than the LHS was allowed has been fixed, i.e. code like:
-  ```nim
-  var a, b: int
-  (a, b) = (1, 2, 3, 4)
-  ```
-  will no longer compile.
-
-- `internalNew` is removed from the `system` module, use `new` instead.
-
-- `bindMethod` in `std/jsffi` is deprecated, don't use it with closures.
-
-- The JS backend now supports lambda lifting for closures. Use `--legacy:jsNoLambdaLifting` to emulate old behaviors.
-
-- The JS backend now supports closure iterators.
-
-- `owner` in `std/macros` is deprecated.
-
-- Ambiguous type symbols in generic procs and templates now generate symchoice nodes.
-  Previously; in templates they would error immediately at the template definition,
-  and in generic procs a type symbol would arbitrarily be captured, losing the
-  information of the other symbols. This means that generic code can now give
-  errors for ambiguous type symbols, and macros operating on generic proc AST
-  may encounter symchoice nodes instead of the arbitrarily resolved type symbol nodes.
-
-- Partial generic instantiation of routines is no longer allowed. Previously
-  it compiled in niche situations due to bugs in the compiler.
-
-  ```nim
-  proc foo[T, U](x: T, y: U) = echo (x, y)
-  proc foo[T, U](x: var T, y: U) = echo "var ", (x, y)
-
-  proc bar[T]() =
-    foo[float](1, "abc")
-
-  bar[int]() # before: (1.0, "abc"), now: type mismatch, missing generic parameter
-  ```
-
-- `const` values now open a new scope for each constant, meaning symbols
-  declared in them can no longer be used outside or in the value of
-  other constants.
-
-  ```nim
-  const foo = (var a = 1; a)
-  const bar = a # error
-  let baz = a # error
-  ```
-
-- The following POSIX wrappers have had their types changed from signed to
-  unsigned types on OSX and FreeBSD/OpenBSD to correct codegen errors:
-  - `Gid` (was `int32`, is now `uint32`)
-  - `Uid` (was `int32`, is now `uint32`)
-  - `Dev` (was `int32`, is now `uint32` on FreeBSD)
-  - `Nlink` (was `int16`, is now `uint32` on OpenBSD and `uint16` on OSX/other BSD)
-  - `sin6_flowinfo` and `sin6_scope_id` fields of `Sockaddr_in6`
-    (were `int32`, are now `uint32`)
-  - `n_net` field of `Tnetent` (was `int32`, is now `uint32`)
-
-- The `Atomic[T]` type on C++ now uses C11 primitives by default instead of
-  `std::atomic`. To use `std::atomic` instead, `-d:nimUseCppAtomics` can be defined.
-
-
-
-
-
-
 ## Standard library additions and changes
 
-[//]: # "Changes:"
-
-- Changed `std/osfiles.copyFile` to allow specifying `bufferSize` instead of a hard-coded one.
-- Changed `std/osfiles.copyFile` to use `POSIX_FADV_SEQUENTIAL` hints for kernel-level aggressive sequential read-aheads.
-- `std/htmlparser` has been moved to a nimble package, use `nimble` or `atlas` to install it.
-- Changed `std/os.copyDir` and `copyDirWithPermissions` to allow skipping special "file" objects like FIFOs, device files, etc on Unix by specifying a `skipSpecial` parameter.
-
-[//]: # "Additions:"
-
-- Added `newStringUninit` to the `system` module, which creates a new string of length `len` like `newString` but with uninitialized content.
-- Added `setLenUninit` to the `system` module, which doesn't initialize
-slots when enlarging a sequence.
-- Added `hasDefaultValue` to `std/typetraits` to check if a type has a valid default value.
-- Added `rangeBase` to `std/typetraits` to obtain the base type of a range type or
-  convert a value with a range type to its base type.
-- Added Viewport API for the JavaScript targets in the `dom` module.
-- Added `toSinglyLinkedRing` and `toDoublyLinkedRing` to `std/lists` to convert from `openArray`s.
-- ORC: To be enabled via `nimOrcStats` there is a new API called `GC_orcStats` that can be used to query how many
-  objects the cyclic collector did free. If the number is zero that is a strong indicator that you can use `--mm:arc`
-  instead of `--mm:orc`.
-- A `$` template is provided for `Path` in `std/paths`.
-- `std/hashes.hash(x:string)` changed to produce a 64-bit string `Hash` (based
-on Google's Farm Hash) which is also often faster than the present one.  Define
-`nimStringHash2` to get the old values back.  `--jsbigint=off` mode always only
-produces the old values.  This may impact your automated tests if they depend
-on hash order in some obvious or indirect way.  Using `sorted` or `OrderedTable`
-is often an easy workaround.
-
-[//]: # "Deprecations:"
-
-- Deprecates `system.newSeqUninitialized`, which is replaced by `newSeqUninit`.
-
-[//]: # "Removals:"
-
-
-
-
-
-
 ## Language changes
 
-- `noInit` can be used in types and fields to disable member initializers in the C++ backend.
-
-- C++ custom constructors initializers see https://nim-lang.org/docs/manual_experimental.html#constructor-initializer
-
-- `member` can be used to attach a procedure to a C++ type.
-
-- Inside a C++ constructor, `result` can be used to access the created object rather than `this`.
-
-- Tuple unpacking changes:
-  - Tuple unpacking assignment now supports using underscores to discard values.
-    ```nim
-    var a, c: int
-    (a, _, c) = (1, 2, 3)
-    ```
-  - Tuple unpacking variable declarations now support type annotations, but
-    only for the entire tuple.
-    ```nim
-    let (a, b): (int, int) = (1, 2)
-    let (a, (b, c)): (byte, (float, cstring)) = (1, (2, "abc"))
-    ```
-
-- The experimental option `--experimental:openSym` has been added to allow
-  captured symbols in generic routine and template bodies respectively to be
-  replaced by symbols injected locally by templates/macros at instantiation
-  time. `bind` may be used to keep the captured symbols over the injected ones
-  regardless of enabling the option, but other methods like renaming the
-  captured symbols should be used instead so that the code is not affected by
-  context changes.
-
-  Since this change may affect runtime behavior, the experimental switch
-  `openSym` needs to be enabled; and a warning is given in the case where an
-  injected symbol would replace a captured symbol not bound by `bind` and
-  the experimental switch isn't enabled.
-
-  ```nim
-  const value = "captured"
-  template foo(x: int, body: untyped): untyped =
-    let value {.inject.} = "injected"
-    body
-
-  proc old[T](): string =
-    foo(123):
-      return value # warning: a new `value` has been injected, use `bind` or turn on `experimental:openSym`
-  echo old[int]() # "captured"
-
-  template oldTempl(): string =
-    block:
-      foo(123):
-        value # warning: a new `value` has been injected, use `bind` or turn on `experimental:openSym`
-  echo oldTempl() # "captured"
-
-  {.experimental: "openSym".}
-
-  proc bar[T](): string =
-    foo(123):
-      return value
-  assert bar[int]() == "injected" # previously it would be "captured"
-
-  proc baz[T](): string =
-    bind value
-    foo(123):
-      return value
-  assert baz[int]() == "captured"
-
-  template barTempl(): string =
-    block:
-      foo(123):
-        value
-  assert barTempl() == "injected" # previously it would be "captured"
-
-  template bazTempl(): string =
-    bind value
-    block:
-      foo(123):
-        value
-  assert bazTempl() == "captured"
-  ```
-
-  This option also generates a new node kind `nnkOpenSym` which contains
-  exactly 1 `nnkSym` node. In the future this might be merged with a slightly
-  modified `nnkOpenSymChoice` node but macros that want to support the
-  experimental feature should still handle `nnkOpenSym`, as the node kind would
-  simply not be generated as opposed to being removed.
-
-  Another experimental switch `genericsOpenSym` exists that enables this behavior
-  at instantiation time, meaning templates etc can enable it specifically when
-  they are being called. However this does not generate `nnkOpenSym` nodes
-  (unless the other switch is enabled) and so doesn't reflect the regular
-  behavior of the switch.
-
-  ```nim
-  const value = "captured"
-  template foo(x: int, body: untyped): untyped =
-    let value {.inject.} = "injected"
-    {.push experimental: "genericsOpenSym".}
-    body
-    {.pop.}
-
-  proc bar[T](): string =
-    foo(123):
-      return value
-  echo bar[int]() # "injected"
-
-  template barTempl(): string =
-    block:
-      var res: string
-      foo(123):
-        res = value
-      res
-  assert barTempl() == "injected"
-  ```
-
-
-
-
-
 ## Compiler changes
 
-- `--nimcache` using a relative path as the argument in a config file is now relative to the config file instead of the current directory.
-
-
-
-
-
 ## Tool changes
 
-- koch now allows bootstrapping with `-d:nimHasLibFFI`, replacing the older option of building the compiler directly w/ the `libffi` nimble package.

changelogs/changelog_X_XX_X.md

@@ -1,4 +1,4 @@
-# v2.xx.x - yyyy-mm-dd
+# v1.xx.x - yyyy-mm-dd
 
 This is an example file.
 The changes should go to changelog.md!

compiler/aliases.nim

@@ -51,16 +51,14 @@ proc isPartOfAux(a, b: PType, marker: var IntSet): TAnalysisResult =
   if compareTypes(a, b, dcEqIgnoreDistinct): return arYes
   case a.kind
   of tyObject:
-    if a.baseClass != nil:
-      result = isPartOfAux(a.baseClass.skipTypes(skipPtrs), b, marker)
+    if a[0] != nil:
+      result = isPartOfAux(a[0].skipTypes(skipPtrs), b, marker)
     if result == arNo: result = isPartOfAux(a.n, b, marker)
   of tyGenericInst, tyDistinct, tyAlias, tySink:
-    result = isPartOfAux(skipModifier(a), b, marker)
-  of tySet, tyArray:
-    result = isPartOfAux(a.elementType, b, marker)
-  of tyTuple:
-    for aa in a.kids:
-      result = isPartOfAux(aa, b, marker)
+    result = isPartOfAux(lastSon(a), b, marker)
+  of tyArray, tySet, tyTuple:
+    for i in 0..<a.len:
+      result = isPartOfAux(a[i], b, marker)
       if result == arYes: return
   else: discard
 

compiler/astalgo.nim

@@ -12,18 +12,24 @@
 # the data structures here are used in various places of the compiler.
 
 import
-  ast, astyaml, options, lineinfos, idents, rodutils,
+  ast, options, lineinfos, ropes, idents, rodutils,
   msgs
 
 import std/[hashes, intsets]
 import std/strutils except addf
 
-export astyaml.treeToYaml, astyaml.typeToYaml, astyaml.symToYaml, astyaml.lineInfoToStr
-
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
 proc hashNode*(p: RootRef): Hash
+proc treeToYaml*(conf: ConfigRef; n: PNode, indent: int = 0, maxRecDepth: int = - 1): Rope
+  # Convert a tree into its YAML representation; this is used by the
+  # YAML code generator and it is invaluable for debugging purposes.
+  # If maxRecDepht <> -1 then it won't print the whole graph.
+proc typeToYaml*(conf: ConfigRef; n: PType, indent: int = 0, maxRecDepth: int = - 1): Rope
+proc symToYaml*(conf: ConfigRef; n: PSym, indent: int = 0, maxRecDepth: int = - 1): Rope
+proc lineInfoToStr*(conf: ConfigRef; info: TLineInfo): Rope
+
 
 # these are for debugging only: They are not really deprecated, but I want
 # the warning so that release versions do not contain debugging statements:
@@ -31,6 +37,15 @@ proc debug*(n: PSym; conf: ConfigRef = nil) {.exportc: "debugSym", deprecated.}
 proc debug*(n: PType; conf: ConfigRef = nil) {.exportc: "debugType", deprecated.}
 proc debug*(n: PNode; conf: ConfigRef = nil) {.exportc: "debugNode", deprecated.}
 
+proc typekinds*(t: PType) {.deprecated.} =
+  var t = t
+  var s = ""
+  while t != nil and t.len > 0:
+    s.add $t.kind
+    s.add " "
+    t = t.lastSon
+  echo s
+
 template debug*(x: PSym|PType|PNode) {.deprecated.} =
   when compiles(c.config):
     debug(c.config, x)
@@ -65,6 +80,16 @@ template mdbg*: bool {.deprecated.} =
   else:
     error()
 
+# --------------------------- ident tables ----------------------------------
+proc idTableGet*(t: TIdTable, key: PIdObj): RootRef
+proc idTableGet*(t: TIdTable, key: int): RootRef
+proc idTablePut*(t: var TIdTable, key: PIdObj, val: RootRef)
+proc idTableHasObjectAsKey*(t: TIdTable, key: PIdObj): bool
+  # checks if `t` contains the `key` (compared by the pointer value, not only
+  # `key`'s id)
+proc idNodeTableGet*(t: TIdNodeTable, key: PIdObj): PNode
+proc idNodeTablePut*(t: var TIdNodeTable, key: PIdObj, val: PNode)
+
 # ---------------------------------------------------------------------------
 
 proc lookupInRecord*(n: PNode, field: PIdent): PSym
@@ -220,6 +245,170 @@ proc mustRehash(length, counter: int): bool =
   assert(length > counter)
   result = (length * 2 < counter * 3) or (length - counter < 4)
 
+proc rspaces(x: int): Rope =
+  # returns x spaces
+  result = rope(spaces(x))
+
+proc toYamlChar(c: char): string =
+  case c
+  of '\0'..'\x1F', '\x7F'..'\xFF': result = "\\u" & strutils.toHex(ord(c), 4)
+  of '\'', '\"', '\\': result = '\\' & c
+  else: result = $c
+
+proc makeYamlString*(s: string): Rope =
+  # We have to split long strings into many ropes. Otherwise
+  # this could trigger InternalError(111). See the ropes module for
+  # further information.
+  const MaxLineLength = 64
+  result = ""
+  var res = "\""
+  for i in 0..<s.len:
+    if (i + 1) mod MaxLineLength == 0:
+      res.add('\"')
+      res.add("\n")
+      result.add(rope(res))
+      res = "\""              # reset
+    res.add(toYamlChar(s[i]))
+  res.add('\"')
+  result.add(rope(res))
+
+proc flagsToStr[T](flags: set[T]): Rope =
+  if flags == {}:
+    result = rope("[]")
+  else:
+    result = ""
+    for x in items(flags):
+      if result != "": result.add(", ")
+      result.add(makeYamlString($x))
+    result = "[" & result & "]"
+
+proc lineInfoToStr(conf: ConfigRef; info: TLineInfo): Rope =
+  result = "[$1, $2, $3]" % [makeYamlString(toFilename(conf, info)),
+                             rope(toLinenumber(info)),
+                             rope(toColumn(info))]
+
+proc treeToYamlAux(conf: ConfigRef; n: PNode, marker: var IntSet,
+                   indent, maxRecDepth: int): Rope
+proc symToYamlAux(conf: ConfigRef; n: PSym, marker: var IntSet,
+                  indent, maxRecDepth: int): Rope
+proc typeToYamlAux(conf: ConfigRef; n: PType, marker: var IntSet,
+                   indent, maxRecDepth: int): Rope
+
+proc symToYamlAux(conf: ConfigRef; n: PSym, marker: var IntSet, indent: int,
+                  maxRecDepth: int): Rope =
+  if n == nil:
+    result = rope("null")
+  elif containsOrIncl(marker, n.id):
+    result = "\"$1\"" % [rope(n.name.s)]
+  else:
+    var ast = treeToYamlAux(conf, n.ast, marker, indent + 2, maxRecDepth - 1)
+                                 #rope("typ"), typeToYamlAux(conf, n.typ, marker,
+                                 #  indent + 2, maxRecDepth - 1),
+    let istr = rspaces(indent + 2)
+    result = rope("{")
+    result.addf("$N$1\"kind\": $2", [istr, makeYamlString($n.kind)])
+    result.addf("$N$1\"name\": $2", [istr, makeYamlString(n.name.s)])
+    result.addf("$N$1\"typ\": $2", [istr, typeToYamlAux(conf, n.typ, marker, indent + 2, maxRecDepth - 1)])
+    if conf != nil:
+      # if we don't pass the config, we probably don't care about the line info
+      result.addf("$N$1\"info\": $2", [istr, lineInfoToStr(conf, n.info)])
+    if card(n.flags) > 0:
+      result.addf("$N$1\"flags\": $2", [istr, flagsToStr(n.flags)])
+    result.addf("$N$1\"magic\": $2", [istr, makeYamlString($n.magic)])
+    result.addf("$N$1\"ast\": $2", [istr, ast])
+    result.addf("$N$1\"options\": $2", [istr, flagsToStr(n.options)])
+    result.addf("$N$1\"position\": $2", [istr, rope(n.position)])
+    result.addf("$N$1\"k\": $2", [istr, makeYamlString($n.loc.k)])
+    result.addf("$N$1\"storage\": $2", [istr, makeYamlString($n.loc.storage)])
+    if card(n.loc.flags) > 0:
+      result.addf("$N$1\"flags\": $2", [istr, makeYamlString($n.loc.flags)])
+    result.addf("$N$1\"r\": $2", [istr, n.loc.r])
+    result.addf("$N$1\"lode\": $2", [istr, treeToYamlAux(conf, n.loc.lode, marker, indent + 2, maxRecDepth - 1)])
+    result.addf("$N$1}", [rspaces(indent)])
+
+proc typeToYamlAux(conf: ConfigRef; n: PType, marker: var IntSet, indent: int,
+                   maxRecDepth: int): Rope =
+  var sonsRope: Rope
+  if n == nil:
+    result = ""
+    sonsRope = rope("null")
+  elif containsOrIncl(marker, n.id):
+    result = ""
+    sonsRope = "\"$1 @$2\"" % [rope($n.kind), rope(
+        strutils.toHex(cast[int](n), sizeof(n) * 2))]
+  else:
+    if n.len > 0:
+      sonsRope = rope("[")
+      for i in 0..<n.len:
+        if i > 0: sonsRope.add(",")
+        sonsRope.addf("$N$1$2", [rspaces(indent + 4), typeToYamlAux(conf, n[i],
+            marker, indent + 4, maxRecDepth - 1)])
+      sonsRope.addf("$N$1]", [rspaces(indent + 2)])
+    else:
+      sonsRope = rope("null")
+
+    let istr = rspaces(indent + 2)
+    result = rope("{")
+    result.addf("$N$1\"kind\": $2", [istr, makeYamlString($n.kind)])
+    result.addf("$N$1\"sym\": $2",  [istr, symToYamlAux(conf, n.sym, marker, indent + 2, maxRecDepth - 1)])
+    result.addf("$N$1\"n\": $2",     [istr, treeToYamlAux(conf, n.n, marker, indent + 2, maxRecDepth - 1)])
+    if card(n.flags) > 0:
+      result.addf("$N$1\"flags\": $2", [istr, flagsToStr(n.flags)])
+    result.addf("$N$1\"callconv\": $2", [istr, makeYamlString($n.callConv)])
+    result.addf("$N$1\"size\": $2", [istr, rope(n.size)])
+    result.addf("$N$1\"align\": $2", [istr, rope(n.align)])
+    result.addf("$N$1\"sons\": $2", [istr, sonsRope])
+
+proc treeToYamlAux(conf: ConfigRef; n: PNode, marker: var IntSet, indent: int,
+                   maxRecDepth: int): Rope =
+  if n == nil:
+    result = rope("null")
+  else:
+    var istr = rspaces(indent + 2)
+    result = "{$N$1\"kind\": $2" % [istr, makeYamlString($n.kind)]
+    if maxRecDepth != 0:
+      if conf != nil:
+        result.addf(",$N$1\"info\": $2", [istr, lineInfoToStr(conf, n.info)])
+      case n.kind
+      of nkCharLit..nkUInt64Lit:
+        result.addf(",$N$1\"intVal\": $2", [istr, rope(n.intVal)])
+      of nkFloatLit, nkFloat32Lit, nkFloat64Lit:
+        result.addf(",$N$1\"floatVal\": $2",
+            [istr, rope(n.floatVal.toStrMaxPrecision)])
+      of nkStrLit..nkTripleStrLit:
+        result.addf(",$N$1\"strVal\": $2", [istr, makeYamlString(n.strVal)])
+      of nkSym:
+        result.addf(",$N$1\"sym\": $2",
+             [istr, symToYamlAux(conf, n.sym, marker, indent + 2, maxRecDepth)])
+      of nkIdent:
+        if n.ident != nil:
+          result.addf(",$N$1\"ident\": $2", [istr, makeYamlString(n.ident.s)])
+        else:
+          result.addf(",$N$1\"ident\": null", [istr])
+      else:
+        if n.len > 0:
+          result.addf(",$N$1\"sons\": [", [istr])
+          for i in 0..<n.len:
+            if i > 0: result.add(",")
+            result.addf("$N$1$2", [rspaces(indent + 4), treeToYamlAux(conf, n[i],
+                marker, indent + 4, maxRecDepth - 1)])
+          result.addf("$N$1]", [istr])
+      result.addf(",$N$1\"typ\": $2",
+           [istr, typeToYamlAux(conf, n.typ, marker, indent + 2, maxRecDepth)])
+    result.addf("$N$1}", [rspaces(indent)])
+
+proc treeToYaml(conf: ConfigRef; n: PNode, indent: int = 0, maxRecDepth: int = - 1): Rope =
+  var marker = initIntSet()
+  result = treeToYamlAux(conf, n, marker, indent, maxRecDepth)
+
+proc typeToYaml(conf: ConfigRef; n: PType, indent: int = 0, maxRecDepth: int = - 1): Rope =
+  var marker = initIntSet()
+  result = typeToYamlAux(conf, n, marker, indent, maxRecDepth)
+
+proc symToYaml(conf: ConfigRef; n: PSym, indent: int = 0, maxRecDepth: int = - 1): Rope =
+  var marker = initIntSet()
+  result = symToYamlAux(conf, n, marker, indent, maxRecDepth)
+
 import std/tables
 
 const backrefStyle = "\e[90m"
@@ -384,12 +573,14 @@ proc value(this: var DebugPrinter; value: PType) =
     this.key "n"
     this.value value.n
 
-  this.key "sons"
-  this.openBracket
-  for i, a in value.ikids:
-    if i > 0: this.comma
-    this.value a
-  this.closeBracket
+  if value.len > 0:
+    this.key "sons"
+    this.openBracket
+    for i in 0..<value.len:
+      this.value value[i]
+      if i != value.len - 1:
+        this.comma
+    this.closeBracket
 
   if value.n != nil:
     this.key "n"
@@ -458,33 +649,30 @@ proc value(this: var DebugPrinter; value: PNode) =
 
 
 proc debug(n: PSym; conf: ConfigRef) =
-  var this = DebugPrinter(
-    visited: initTable[pointer, int](),
-    renderSymType: true,
-    useColor: not defined(windows)
-  )
+  var this: DebugPrinter
+  this.visited = initTable[pointer, int]()
+  this.renderSymType = true
+  this.useColor = not defined(windows)
   this.value(n)
   echo($this.res)
 
 proc debug(n: PType; conf: ConfigRef) =
-  var this = DebugPrinter(
-    visited: initTable[pointer, int](),
-    renderSymType: true,
-    useColor: not defined(windows)
-  )
+  var this: DebugPrinter
+  this.visited = initTable[pointer, int]()
+  this.renderSymType = true
+  this.useColor = not defined(windows)
   this.value(n)
   echo($this.res)
 
 proc debug(n: PNode; conf: ConfigRef) =
-  var this = DebugPrinter(
-    visited: initTable[pointer, int](),
-    renderSymType: false,
-    useColor: not defined(windows)
-  )
+  var this: DebugPrinter
+  this.visited = initTable[pointer, int]()
+  #this.renderSymType = true
+  this.useColor = not defined(windows)
   this.value(n)
   echo($this.res)
 
-proc nextTry(h, maxHash: Hash): Hash {.inline.} =
+proc nextTry(h, maxHash: Hash): Hash =
   result = ((5 * h) + 1) and maxHash
   # For any initial h in range(maxHash), repeating that maxHash times
   # generates each int in range(maxHash) exactly once (see any text on
@@ -707,12 +895,125 @@ proc initTabIter*(ti: var TTabIter, tab: TStrTable): PSym =
     result = nextIter(ti, tab)
 
 iterator items*(tab: TStrTable): PSym =
-  var it: TTabIter = default(TTabIter)
+  var it: TTabIter
   var s = initTabIter(it, tab)
   while s != nil:
     yield s
     s = nextIter(it, tab)
 
+proc hasEmptySlot(data: TIdPairSeq): bool =
+  for h in 0..high(data):
+    if data[h].key == nil:
+      return true
+  result = false
+
+proc idTableRawGet(t: TIdTable, key: int): int =
+  var h: Hash
+  h = key and high(t.data)    # start with real hash value
+  while t.data[h].key != nil:
+    if t.data[h].key.id == key:
+      return h
+    h = nextTry(h, high(t.data))
+  result = - 1
+
+proc idTableHasObjectAsKey(t: TIdTable, key: PIdObj): bool =
+  var index = idTableRawGet(t, key.id)
+  if index >= 0: result = t.data[index].key == key
+  else: result = false
+
+proc idTableGet(t: TIdTable, key: PIdObj): RootRef =
+  var index = idTableRawGet(t, key.id)
+  if index >= 0: result = t.data[index].val
+  else: result = nil
+
+proc idTableGet(t: TIdTable, key: int): RootRef =
+  var index = idTableRawGet(t, key)
+  if index >= 0: result = t.data[index].val
+  else: result = nil
+
+iterator pairs*(t: TIdTable): tuple[key: int, value: RootRef] =
+  for i in 0..high(t.data):
+    if t.data[i].key != nil:
+      yield (t.data[i].key.id, t.data[i].val)
+
+proc idTableRawInsert(data: var TIdPairSeq, key: PIdObj, val: RootRef) =
+  var h: Hash
+  h = key.id and high(data)
+  while data[h].key != nil:
+    assert(data[h].key.id != key.id)
+    h = nextTry(h, high(data))
+  assert(data[h].key == nil)
+  data[h].key = key
+  data[h].val = val
+
+proc idTablePut(t: var TIdTable, key: PIdObj, val: RootRef) =
+  var
+    index: int
+    n: TIdPairSeq
+  index = idTableRawGet(t, key.id)
+  if index >= 0:
+    assert(t.data[index].key != nil)
+    t.data[index].val = val
+  else:
+    if mustRehash(t.data.len, t.counter):
+      newSeq(n, t.data.len * GrowthFactor)
+      for i in 0..high(t.data):
+        if t.data[i].key != nil:
+          idTableRawInsert(n, t.data[i].key, t.data[i].val)
+      assert(hasEmptySlot(n))
+      swap(t.data, n)
+    idTableRawInsert(t.data, key, val)
+    inc(t.counter)
+
+iterator idTablePairs*(t: TIdTable): tuple[key: PIdObj, val: RootRef] =
+  for i in 0..high(t.data):
+    if not isNil(t.data[i].key): yield (t.data[i].key, t.data[i].val)
+
+proc idNodeTableRawGet(t: TIdNodeTable, key: PIdObj): int =
+  var h: Hash
+  h = key.id and high(t.data) # start with real hash value
+  while t.data[h].key != nil:
+    if t.data[h].key.id == key.id:
+      return h
+    h = nextTry(h, high(t.data))
+  result = - 1
+
+proc idNodeTableGet(t: TIdNodeTable, key: PIdObj): PNode =
+  var index: int
+  index = idNodeTableRawGet(t, key)
+  if index >= 0: result = t.data[index].val
+  else: result = nil
+
+proc idNodeTableRawInsert(data: var TIdNodePairSeq, key: PIdObj, val: PNode) =
+  var h: Hash
+  h = key.id and high(data)
+  while data[h].key != nil:
+    assert(data[h].key.id != key.id)
+    h = nextTry(h, high(data))
+  assert(data[h].key == nil)
+  data[h].key = key
+  data[h].val = val
+
+proc idNodeTablePut(t: var TIdNodeTable, key: PIdObj, val: PNode) =
+  var index = idNodeTableRawGet(t, key)
+  if index >= 0:
+    assert(t.data[index].key != nil)
+    t.data[index].val = val
+  else:
+    if mustRehash(t.data.len, t.counter):
+      var n: TIdNodePairSeq
+      newSeq(n, t.data.len * GrowthFactor)
+      for i in 0..high(t.data):
+        if t.data[i].key != nil:
+          idNodeTableRawInsert(n, t.data[i].key, t.data[i].val)
+      swap(t.data, n)
+    idNodeTableRawInsert(t.data, key, val)
+    inc(t.counter)
+
+iterator pairs*(t: TIdNodeTable): tuple[key: PIdObj, val: PNode] =
+  for i in 0..high(t.data):
+    if not isNil(t.data[i].key): yield (t.data[i].key, t.data[i].val)
+
 proc initIITable(x: var TIITable) =
   x.counter = 0
   newSeq(x.data, StartSize)
@@ -758,6 +1059,14 @@ proc iiTablePut(t: var TIITable, key, val: int) =
     iiTableRawInsert(t.data, key, val)
     inc(t.counter)
 
+proc isAddrNode*(n: PNode): bool =
+  case n.kind
+    of nkAddr, nkHiddenAddr: true
+    of nkCallKinds:
+      if n[0].kind == nkSym and n[0].sym.magic == mAddr: true
+      else: false
+    else: false
+
 proc listSymbolNames*(symbols: openArray[PSym]): string =
   result = ""
   for sym in symbols:

compiler/astmsgs.nim

@@ -5,7 +5,7 @@ import options, ast, msgs
 proc typSym*(t: PType): PSym =
   result = t.sym
   if result == nil and t.kind == tyGenericInst: # this might need to be refined
-    result = t.genericHead.sym
+    result = t[0].sym
 
 proc addDeclaredLoc*(result: var string, conf: ConfigRef; sym: PSym) =
   result.add " [$1 declared in $2]" % [sym.kind.toHumanStr, toFileLineCol(conf, sym.info)]
@@ -24,12 +24,6 @@ proc addDeclaredLoc*(result: var string, conf: ConfigRef; typ: PType) =
     result.add " declared in " & toFileLineCol(conf, typ.sym.info)
   result.add "]"
 
-proc addTypeNodeDeclaredLoc*(result: var string, conf: ConfigRef; typ: PType) =
-  result.add " [$1" % typ.kind.toHumanStr
-  if typ.sym != nil:
-    result.add " declared in " & toFileLineCol(conf, typ.sym.info)
-  result.add "]"
-
 proc addDeclaredLocMaybe*(result: var string, conf: ConfigRef; typ: PType) =
   if optDeclaredLocs in conf.globalOptions: addDeclaredLoc(result, conf, typ)
 

compiler/astyaml.nim

@@ -1,154 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2012 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-# AST YAML printing
-
-import "."/[ast, lineinfos, msgs, options, rodutils]
-import std/[intsets, strutils]
-
-proc addYamlString*(res: var string; s: string) =
-  res.add "\""
-  for c in s:
-    case c
-    of '\0' .. '\x1F', '\x7F' .. '\xFF':
-      res.add("\\u" & strutils.toHex(ord(c), 4))
-    of '\"', '\\':
-      res.add '\\' & c
-    else:
-      res.add c
-
-  res.add('\"')
-
-proc makeYamlString(s: string): string =
-  result = ""
-  result.addYamlString(s)
-
-proc flagsToStr[T](flags: set[T]): string =
-  if flags == {}:
-    result = "[]"
-  else:
-    result = ""
-    for x in items(flags):
-      if result != "":
-        result.add(", ")
-      result.addYamlString($x)
-    result = "[" & result & "]"
-
-proc lineInfoToStr*(conf: ConfigRef; info: TLineInfo): string =
-  result = "["
-  result.addYamlString(toFilename(conf, info))
-  result.addf ", $1, $2]", [toLinenumber(info), toColumn(info)]
-
-proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; indent, maxRecDepth: int)
-proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; indent, maxRecDepth: int)
-proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; indent, maxRecDepth: int)
-
-proc symToYamlAux(res: var string; conf: ConfigRef; n: PSym; marker: var IntSet; indent: int; maxRecDepth: int) =
-  if n == nil:
-    res.add("null")
-  elif containsOrIncl(marker, n.id):
-    res.addYamlString(n.name.s)
-  else:
-    let istr = spaces(indent * 4)
-
-    res.addf("kind: $1", [makeYamlString($n.kind)])
-    res.addf("\n$1name: $2", [istr, makeYamlString(n.name.s)])
-    res.addf("\n$1typ: ", [istr])
-    res.typeToYamlAux(conf, n.typ, marker, indent + 1, maxRecDepth - 1)
-    if conf != nil:
-      # if we don't pass the config, we probably don't care about the line info
-      res.addf("\n$1info: $2", [istr, lineInfoToStr(conf, n.info)])
-    if card(n.flags) > 0:
-      res.addf("\n$1flags: $2", [istr, flagsToStr(n.flags)])
-    res.addf("\n$1magic: $2", [istr, makeYamlString($n.magic)])
-    res.addf("\n$1ast: ", [istr])
-    res.treeToYamlAux(conf, n.ast, marker, indent + 1, maxRecDepth - 1)
-    res.addf("\n$1options: $2", [istr, flagsToStr(n.options)])
-    res.addf("\n$1position: $2", [istr, $n.position])
-    res.addf("\n$1k: $2", [istr, makeYamlString($n.loc.k)])
-    res.addf("\n$1storage: $2", [istr, makeYamlString($n.loc.storage)])
-    if card(n.loc.flags) > 0:
-      res.addf("\n$1flags: $2", [istr, makeYamlString($n.loc.flags)])
-    res.addf("\n$1snippet: $2", [istr, n.loc.snippet])
-    res.addf("\n$1lode: $2", [istr])
-    res.treeToYamlAux(conf, n.loc.lode, marker, indent + 1, maxRecDepth - 1)
-
-proc typeToYamlAux(res: var string; conf: ConfigRef; n: PType; marker: var IntSet; indent: int; maxRecDepth: int) =
-  if n == nil:
-    res.add("null")
-  elif containsOrIncl(marker, n.id):
-    res.addf "\"$1 @$2\"" % [$n.kind, strutils.toHex(cast[uint](n), sizeof(n) * 2)]
-  else:
-    let istr = spaces(indent * 4)
-    res.addf("kind: $2", [istr, makeYamlString($n.kind)])
-    res.addf("\n$1sym: ")
-    res.symToYamlAux(conf, n.sym, marker, indent + 1, maxRecDepth - 1)
-    res.addf("\n$1n: ")
-    res.treeToYamlAux(conf, n.n, marker, indent + 1, maxRecDepth - 1)
-    if card(n.flags) > 0:
-      res.addf("\n$1flags: $2", [istr, flagsToStr(n.flags)])
-    res.addf("\n$1callconv: $2", [istr, makeYamlString($n.callConv)])
-    res.addf("\n$1size: $2", [istr, $(n.size)])
-    res.addf("\n$1align: $2", [istr, $(n.align)])
-    if n.hasElementType:
-      res.addf("\n$1sons:")
-      for a in n.kids:
-        res.addf("\n  - ")
-        res.typeToYamlAux(conf, a, marker, indent + 1, maxRecDepth - 1)
-
-proc treeToYamlAux(res: var string; conf: ConfigRef; n: PNode; marker: var IntSet; indent: int;
-                   maxRecDepth: int) =
-  if n == nil:
-    res.add("null")
-  else:
-    var istr = spaces(indent * 4)
-    res.addf("kind: $1" % [makeYamlString($n.kind)])
-
-    if maxRecDepth != 0:
-      if conf != nil:
-        res.addf("\n$1info: $2", [istr, lineInfoToStr(conf, n.info)])
-      case n.kind
-      of nkCharLit .. nkInt64Lit:
-        res.addf("\n$1intVal: $2", [istr, $(n.intVal)])
-      of nkFloatLit, nkFloat32Lit, nkFloat64Lit:
-        res.addf("\n$1floatVal: $2", [istr, n.floatVal.toStrMaxPrecision])
-      of nkStrLit .. nkTripleStrLit:
-        res.addf("\n$1strVal: $2", [istr, makeYamlString(n.strVal)])
-      of nkSym:
-        res.addf("\n$1sym: ", [istr])
-        res.symToYamlAux(conf, n.sym, marker, indent + 1, maxRecDepth)
-      of nkIdent:
-        if n.ident != nil:
-          res.addf("\n$1ident: $2", [istr, makeYamlString(n.ident.s)])
-        else:
-          res.addf("\n$1ident: null", [istr])
-      else:
-        if n.len > 0:
-          res.addf("\n$1sons: ", [istr])
-          for i in 0 ..< n.len:
-            res.addf("\n$1  - ", [istr])
-            res.treeToYamlAux(conf, n[i], marker, indent + 1, maxRecDepth - 1)
-      if n.typ != nil:
-        res.addf("\n$1typ: ", [istr])
-        res.typeToYamlAux(conf, n.typ, marker, indent + 1, maxRecDepth)
-
-proc treeToYaml*(conf: ConfigRef; n: PNode; indent: int = 0; maxRecDepth: int = -1): string =
-  var marker = initIntSet()
-  result = newStringOfCap(1024)
-  result.treeToYamlAux(conf, n, marker, indent, maxRecDepth)
-
-proc typeToYaml*(conf: ConfigRef; n: PType; indent: int = 0; maxRecDepth: int = -1): string =
-  var marker = initIntSet()
-  result = newStringOfCap(1024)
-  result.typeToYamlAux(conf, n, marker, indent, maxRecDepth)
-
-proc symToYaml*(conf: ConfigRef; n: PSym; indent: int = 0; maxRecDepth: int = -1): string =
-  var marker = initIntSet()
-  result = newStringOfCap(1024)
-  result.symToYamlAux(conf, n, marker, indent, maxRecDepth)

compiler/backendpragmas.nim

@@ -0,0 +1,25 @@
+import pragmas, options, ast, trees
+
+proc pushBackendOption(optionsStack: var seq[TOptions], options: var TOptions) =
+  optionsStack.add options
+
+proc popBackendOption(optionsStack: var seq[TOptions], options: var TOptions) =
+  options = optionsStack[^1]
+  optionsStack.setLen(optionsStack.len-1)
+
+proc processPushBackendOption*(optionsStack: var seq[TOptions], options: var TOptions,
+                           n: PNode, start: int) =
+  pushBackendOption(optionsStack, options)
+  for i in start..<n.len:
+    let it = n[i]
+    if it.kind in nkPragmaCallKinds and it.len == 2 and it[1].kind == nkIntLit:
+      let sw = whichPragma(it[0])
+      let opts = pragmaToOptions(sw)
+      if opts != {}:
+        if it[1].intVal != 0:
+          options.incl opts
+        else:
+          options.excl opts
+
+template processPopBackendOption*(optionsStack: var seq[TOptions], options: var TOptions) =
+  popBackendOption(optionsStack, options)

compiler/cbuilderbase.nim

@@ -1,88 +0,0 @@
-import ropes, int128
-
-type
-  Snippet* = string
-  Builder* = object
-    buf*: string
-
-template newBuilder*(s: string): Builder =
-  Builder(buf: s)
-
-proc extract*(builder: Builder): Snippet =
-  builder.buf
-
-proc add*(builder: var Builder, s: string) =
-  builder.buf.add(s)
-
-proc add*(builder: var Builder, s: char) =
-  builder.buf.add(s)
-
-proc addIntValue*(builder: var Builder, val: int) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: int64) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: uint64) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: Int128) =
-  builder.buf.addInt128(val)
-
-template cIntValue*(val: int): Snippet = $val
-template cIntValue*(val: int64): Snippet = $val
-template cIntValue*(val: uint64): Snippet = $val
-template cIntValue*(val: Int128): Snippet = $val
-
-import std/formatfloat
-
-proc addFloatValue*(builder: var Builder, val: float) =
-  builder.buf.addFloat(val)
-
-template cFloatValue*(val: float): Snippet = $val
-
-proc addInt64Literal*(result: var Builder; i: BiggestInt) =
-  if i > low(int64):
-    result.add "IL64($1)" % [rope(i)]
-  else:
-    result.add "(IL64(-9223372036854775807) - IL64(1))"
-
-proc addUint64Literal*(result: var Builder; i: uint64) =
-  result.add rope($i & "ULL")
-
-proc addIntLiteral*(result: var Builder; i: BiggestInt) =
-  if i > low(int32) and i <= high(int32):
-    result.addIntValue(i)
-  elif i == low(int32):
-    # Nim has the same bug for the same reasons :-)
-    result.add "(-2147483647 -1)"
-  elif i > low(int64):
-    result.add "IL64($1)" % [rope(i)]
-  else:
-    result.add "(IL64(-9223372036854775807) - IL64(1))"
-
-proc addIntLiteral*(result: var Builder; i: Int128) =
-  addIntLiteral(result, toInt64(i))
-
-proc cInt64Literal*(i: BiggestInt): Snippet =
-  if i > low(int64):
-    result = "IL64($1)" % [rope(i)]
-  else:
-    result = "(IL64(-9223372036854775807) - IL64(1))"
-
-proc cUint64Literal*(i: uint64): Snippet =
-  result = $i & "ULL"
-
-proc cIntLiteral*(i: BiggestInt): Snippet =
-  if i > low(int32) and i <= high(int32):
-    result = rope(i)
-  elif i == low(int32):
-    # Nim has the same bug for the same reasons :-)
-    result = "(-2147483647 -1)"
-  elif i > low(int64):
-    result = "IL64($1)" % [rope(i)]
-  else:
-    result = "(IL64(-9223372036854775807) - IL64(1))"
-
-proc cIntLiteral*(i: Int128): Snippet =
-  result = cIntLiteral(toInt64(i))

compiler/cbuilderdecls.nim

@@ -1,527 +0,0 @@
-type VarKind = enum
-  Local
-  Global
-  Threadvar
-  Const
-  AlwaysConst ## const even on C++
-
-proc addVarHeader(builder: var Builder, kind: VarKind) =
-  ## adds modifiers for given var kind:
-  ## Local has no modifier
-  ## Global has `static` modifier
-  ## Const has `static NIM_CONST` modifier
-  ## AlwaysConst has `static const` modifier (NIM_CONST is no-op on C++)
-  ## Threadvar is unimplemented
-  case kind
-  of Local: discard
-  of Global:
-    builder.add("static ")
-  of Const:
-    builder.add("static NIM_CONST ")
-  of AlwaysConst:
-    builder.add("static const ")
-  of Threadvar:
-    doAssert false, "unimplemented"
-
-proc addVar(builder: var Builder, kind: VarKind = Local, name: string, typ: Snippet, initializer: Snippet = "") =
-  ## adds a variable declaration to the builder
-  builder.addVarHeader(kind)
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-  if initializer.len != 0:
-    builder.add(" = ")
-    builder.add(initializer)
-  builder.add(";\n")
-
-template addVarWithType(builder: var Builder, kind: VarKind = Local, name: string, body: typed) =
-  ## adds a variable declaration to the builder, with the `body` building the type
-  builder.addVarHeader(kind)
-  body
-  builder.add(" ")
-  builder.add(name)
-  builder.add(";\n")
-
-template addVarWithInitializer(builder: var Builder, kind: VarKind = Local, name: string,
-                               typ: Snippet, initializerBody: typed) =
-  ## adds a variable declaration to the builder, with
-  ## `initializerBody` building the initializer. initializer must be provided
-  builder.addVarHeader(kind)
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-  builder.add(" = ")
-  initializerBody
-  builder.add(";\n")
-
-template addVarWithTypeAndInitializer(builder: var Builder, kind: VarKind = Local, name: string,
-                                      typeBody, initializerBody: typed) =
-  ## adds a variable declaration to the builder, with `typeBody` building the type, and
-  ## `initializerBody` building the initializer. initializer must be provided
-  builder.addVarHeader(kind)
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.add(" = ")
-  initializerBody
-  builder.add(";\n")
-
-proc addArrayVar(builder: var Builder, kind: VarKind = Local, name: string, elementType: Snippet, len: int, initializer: Snippet = "") =
-  ## adds an array variable declaration to the builder
-  builder.addVarHeader(kind)
-  builder.add(elementType)
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.add("]")
-  if initializer.len != 0:
-    builder.add(" = ")
-    builder.add(initializer)
-  builder.add(";\n")
-
-template addArrayVarWithInitializer(builder: var Builder, kind: VarKind = Local, name: string, elementType: Snippet, len: int, body: typed) =
-  ## adds an array variable declaration to the builder with the initializer built according to `body`
-  builder.addVarHeader(kind)
-  builder.add(elementType)
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.add("] = ")
-  body
-  builder.add(";\n")
-
-template addTypedef(builder: var Builder, name: string, typeBody: typed) =
-  ## adds a typedef declaration to the builder with name `name` and type as
-  ## built in `typeBody`
-  builder.add("typedef ")
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.add(";\n")
-
-proc addProcTypedef(builder: var Builder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  builder.add("typedef ")
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  builder.add(";\n")
-
-template addArrayTypedef(builder: var Builder, name: string, len: BiggestInt, typeBody: typed) =
-  ## adds an array typedef declaration to the builder with name `name`,
-  ## length `len`, and element type as built in `typeBody`
-  builder.add("typedef ")
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.add("];\n")
-
-type
-  StructInitializerKind = enum
-    siOrderedStruct ## struct constructor, but without named fields on C
-    siNamedStruct ## struct constructor, with named fields i.e. C99 designated initializer
-    siArray ## array constructor
-    siWrapper ## wrapper for a single field, generates it verbatim
-
-  StructInitializer = object
-    ## context for building struct initializers, i.e. `{ field1, field2 }`
-    kind: StructInitializerKind
-      ## if true, fields will not be named, instead values are placed in order
-    needsComma: bool
-
-proc initStructInitializer(builder: var Builder, kind: StructInitializerKind): StructInitializer =
-  ## starts building a struct initializer, i.e. braced initializer list
-  result = StructInitializer(kind: kind, needsComma: false)
-  if kind != siWrapper:
-    builder.add("{")
-
-template addField(builder: var Builder, constr: var StructInitializer, name: string, valueBody: typed) =
-  ## adds a field to a struct initializer, with the value built in `valueBody`
-  if constr.needsComma:
-    assert constr.kind != siWrapper, "wrapper constructor cannot have multiple fields"
-    builder.add(", ")
-  else:
-    constr.needsComma = true
-  case constr.kind
-  of siArray, siWrapper:
-    # no name, can just add value
-    valueBody
-  of siOrderedStruct:
-    # no name, can just add value on C
-    assert name.len != 0, "name has to be given for struct initializer field"
-    valueBody
-  of siNamedStruct:
-    assert name.len != 0, "name has to be given for struct initializer field"
-    builder.add(".")
-    builder.add(name)
-    builder.add(" = ")
-    valueBody
-
-proc finishStructInitializer(builder: var Builder, constr: StructInitializer) =
-  ## finishes building a struct initializer
-  if constr.kind != siWrapper:
-    builder.add("}")
-
-template addStructInitializer(builder: var Builder, constr: out StructInitializer, kind: StructInitializerKind, body: typed) =
-  ## builds a struct initializer, i.e. `{ field1, field2 }`
-  ## a `var StructInitializer` must be declared and passed as a parameter so
-  ## that it can be used with `addField`
-  constr = builder.initStructInitializer(kind)
-  body
-  builder.finishStructInitializer(constr)
-
-proc addField(obj: var Builder; name, typ: Snippet; isFlexArray: bool = false; initializer: Snippet = "") =
-  ## adds a field inside a struct/union type
-  obj.add('\t')
-  obj.add(typ)
-  obj.add(" ")
-  obj.add(name)
-  if isFlexArray:
-    obj.add("[SEQ_DECL_SIZE]")
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addArrayField(obj: var Builder; name, elementType: Snippet; len: int; initializer: Snippet = "") =
-  ## adds an array field inside a struct/union type
-  obj.add('\t')
-  obj.add(elementType)
-  obj.add(" ")
-  obj.add(name)
-  obj.add("[")
-  obj.addIntValue(len)
-  obj.add("]")
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bool = false; initializer: Snippet = "") =
-  ## adds an field inside a struct/union type, based on an `skField` symbol
-  obj.add('\t')
-  if field.alignment > 0:
-    obj.add("NIM_ALIGN(")
-    obj.addIntValue(field.alignment)
-    obj.add(") ")
-  obj.add(typ)
-  if sfNoalias in field.flags:
-    obj.add(" NIM_NOALIAS")
-  obj.add(" ")
-  obj.add(name)
-  if isFlexArray:
-    obj.add("[SEQ_DECL_SIZE]")
-  if field.bitsize != 0:
-    obj.add(":")
-    obj.addIntValue(field.bitsize)
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addProcField(obj: var Builder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  obj.add(CallingConvToStr[callConv])
-  obj.add("_PTR(")
-  obj.add(rettype)
-  obj.add(", ")
-  obj.add(name)
-  obj.add(")")
-  obj.add(params)
-  obj.add(";\n")
-
-type
-  BaseClassKind = enum
-    ## denotes how and whether or not the base class/RTTI should be stored
-    bcNone, bcCppInherit, bcSupField, bcNoneRtti, bcNoneTinyRtti
-  StructBuilderInfo = object
-    ## context for building `struct` types
-    baseKind: BaseClassKind
-    named: bool
-    preFieldsLen: int
-
-proc structOrUnion(t: PType): Snippet =
-  let t = t.skipTypes({tyAlias, tySink})
-  if tfUnion in t.flags: "union"
-  else: "struct"
-
-proc startSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Snippet): StructBuilderInfo =
-  result = StructBuilderInfo(baseKind: bcNone, named: name.len != 0)
-  obj.add("struct")
-  if result.named:
-    obj.add(" ")
-    obj.add(name)
-  if baseType.len != 0:
-    if m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  if result.baseKind == bcCppInherit:
-    obj.add(" : public ")
-    obj.add(baseType)
-  obj.add(" ")
-  obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
-  if result.baseKind == bcSupField:
-    obj.addField(name = "Sup", typ = baseType)
-
-proc finishSimpleStruct(obj: var Builder; m: BModule; info: StructBuilderInfo) =
-  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len:
-    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = "char")
-  if info.named:
-    obj.add("};\n")
-  else:
-    obj.add("}")
-
-template addSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Snippet; body: typed) =
-  ## builds a struct type not based on a Nim type with fields according to `body`,
-  ## `name` can be empty to build as a type expression and not a statement
-  let info = startSimpleStruct(obj, m, name, baseType)
-  body
-  finishSimpleStruct(obj, m, info)
-
-proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType: Snippet): StructBuilderInfo =
-  result = StructBuilderInfo(baseKind: bcNone, named: name.len != 0)
-  if tfPacked in t.flags:
-    if hasAttribute in CC[m.config.cCompiler].props:
-      obj.add(structOrUnion(t))
-      obj.add(" __attribute__((__packed__))")
-    else:
-      obj.add("#pragma pack(push, 1)\n")
-      obj.add(structOrUnion(t))
-  else:
-    obj.add(structOrUnion(t))
-  if result.named:
-    obj.add(" ")
-    obj.add(name)
-  if t.kind == tyObject:
-    if t.baseClass == nil:
-      if lacksMTypeField(t):
-        result.baseKind = bcNone
-      elif optTinyRtti in m.config.globalOptions:
-        result.baseKind = bcNoneTinyRtti
-      else:
-        result.baseKind = bcNoneRtti
-    elif m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  elif baseType.len != 0:
-    if m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  if result.baseKind == bcCppInherit:
-    obj.add(" : public ")
-    obj.add(baseType)
-  obj.add(" ")
-  obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
-  case result.baseKind
-  of bcNone:
-    # rest of the options add a field or don't need it due to inheritance,
-    # we need to add the dummy field for uncheckedarray ahead of time
-    # so that it remains trailing
-    if t.itemId notin m.g.graph.memberProcsPerType and
-        t.n != nil and t.n.len == 1 and t.n[0].kind == nkSym and
-        t.n[0].sym.typ.skipTypes(abstractInst).kind == tyUncheckedArray:
-      # only consists of flexible array field, add *initial* dummy field
-      obj.addField(name = "dummy", typ = "char")
-  of bcCppInherit: discard
-  of bcNoneRtti:
-    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimType")))
-  of bcNoneTinyRtti:
-    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimTypeV2")))
-  of bcSupField:
-    obj.addField(name = "Sup", typ = baseType)
-
-proc finishStruct(obj: var Builder; m: BModule; t: PType; info: StructBuilderInfo) =
-  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len and
-      t.itemId notin m.g.graph.memberProcsPerType:
-    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = "char")
-  if info.named:
-    obj.add("};\n")
-  else:
-    obj.add("}")
-  if tfPacked in t.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    obj.add("#pragma pack(pop)\n")
-
-template addStruct(obj: var Builder; m: BModule; typ: PType; name: string; baseType: Snippet; body: typed) =
-  ## builds a struct type directly based on `typ` with fields according to `body`,
-  ## `name` can be empty to build as a type expression and not a statement
-  let info = startStruct(obj, m, typ, name, baseType)
-  body
-  finishStruct(obj, m, typ, info)
-
-template addFieldWithStructType(obj: var Builder; m: BModule; parentTyp: PType; fieldName: string, body: typed) =
-  ## adds a field with a `struct { ... }` type, building the fields according to `body`
-  obj.add('\t')
-  if tfPacked in parentTyp.flags:
-    if hasAttribute in CC[m.config.cCompiler].props:
-      obj.add("struct __attribute__((__packed__)) {\n")
-    else:
-      obj.add("#pragma pack(push, 1)\nstruct {")
-  else:
-    obj.add("struct {\n")
-  body
-  obj.add("} ")
-  obj.add(fieldName)
-  obj.add(";\n")
-  if tfPacked in parentTyp.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    result.add("#pragma pack(pop)\n")
-
-template addAnonUnion(obj: var Builder; body: typed) =
-  ## adds an anonymous union i.e. `union { ... };` with fields according to `body`
-  obj.add "union{\n"
-  body
-  obj.add("};\n")
-
-type DeclVisibility = enum
-  None
-  Extern
-  ExternC
-  ImportLib
-  ExportLib
-  ExportLibVar
-  Private
-  StaticProc
-
-template addDeclWithVisibility(builder: var Builder, visibility: DeclVisibility, declBody: typed) =
-  ## adds a declaration as in `declBody` with the given visibility
-  case visibility
-  of None: discard
-  of Extern:
-    builder.add("extern ")
-  of ExternC:
-    builder.add("extern \"C\" ")
-  of ImportLib:
-    builder.add("N_LIB_IMPORT ")
-  of ExportLib:
-    builder.add("N_LIB_EXPORT ")
-  of ExportLibVar:
-    builder.add("N_LIB_EXPORT_VAR ")
-  of Private:
-    builder.add("N_LIB_PRIVATE ")
-  of StaticProc:
-    builder.add("static ")
-  declBody
-
-type ProcParamBuilder = object
-  needsComma: bool
-
-proc initProcParamBuilder(builder: var Builder): ProcParamBuilder =
-  result = ProcParamBuilder(needsComma: false)
-  builder.add("(")
-
-proc finishProcParamBuilder(builder: var Builder, params: ProcParamBuilder) =
-  if params.needsComma:
-    builder.add(")")
-  else:
-    builder.add("void)")
-
-template cgDeclFrmt*(s: PSym): string =
-  s.constraint.strVal
-
-proc addParam(builder: var Builder, params: var ProcParamBuilder, name: string, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-
-proc addParam(builder: var Builder, params: var ProcParamBuilder, param: PSym, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  var modifiedTyp = typ
-  if sfNoalias in param.flags:
-    modifiedTyp.add(" NIM_NOALIAS")
-  if sfCodegenDecl notin param.flags:
-    builder.add(modifiedTyp)
-    builder.add(" ")
-    builder.add(param.loc.snippet)
-  else:
-    builder.add runtimeFormat(param.cgDeclFrmt, [modifiedTyp, param.loc.snippet])
-
-proc addUnnamedParam(builder: var Builder, params: var ProcParamBuilder, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add(typ)
-
-proc addVarargsParam(builder: var Builder, params: var ProcParamBuilder) =
-  # does not exist in NIFC, needs to be proc pragma
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add("...")
-
-template addProcParams(builder: var Builder, params: out ProcParamBuilder, body: typed) =
-  params = initProcParamBuilder(builder)
-  body
-  finishProcParamBuilder(builder, params)
-
-proc addProcHeader(builder: var Builder, m: BModule, prc: PSym, name: string, params, rettype: Snippet, addAttributes: bool) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  let noreturn = isNoReturn(m, prc)
-  if sfPure in prc.flags and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-    builder.add("__declspec(naked) ")
-  if noreturn and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-    builder.add("__declspec(noreturn) ")
-  builder.add(CallingConvToStr[prc.typ.callConv])
-  builder.add("(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  if addAttributes:
-    if sfPure in prc.flags and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((naked))")
-    if noreturn and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((noreturn))")
-
-proc finishProcHeaderAsProto(builder: var Builder) =
-  builder.add(";\n")
-
-template finishProcHeaderWithBody(builder: var Builder, body: typed) =
-  builder.add(" {\n")
-  body
-  builder.add("}\n\n")
-
-proc addProcVar(builder: var Builder, m: BModule, prc: PSym, name: string, params, rettype: Snippet,
-                isStatic = false, ignoreAttributes = false) =
-  # on nifc, builds full variable
-  if isStatic:
-    builder.add("static ")
-  let noreturn = isNoReturn(m, prc)
-  if not ignoreAttributes:
-    if sfPure in prc.flags and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-      builder.add("__declspec(naked) ")
-    if noreturn and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-      builder.add("__declspec(noreturn) ")
-  builder.add(CallingConvToStr[prc.typ.callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  if not ignoreAttributes:
-    if sfPure in prc.flags and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((naked))")
-    if noreturn and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((noreturn))")
-  # ensure we are just adding a variable:
-  builder.add(";\n")

compiler/cbuilderexprs.nim

@@ -1,232 +0,0 @@
-# XXX make complex ones like bitOr use builder instead
-# XXX add stuff like NI, NIM_NIL as constants
-
-proc constType(t: Snippet): Snippet =
-  # needs manipulation of `t` in nifc
-  "NIM_CONST " & t
-
-proc constPtrType(t: Snippet): Snippet =
-  t & "* NIM_CONST"
-
-proc ptrConstType(t: Snippet): Snippet =
-  "NIM_CONST " & t & "*"
-
-proc ptrType(t: Snippet): Snippet =
-  t & "*"
-
-const
-  CallingConvToStr: array[TCallingConvention, string] = ["N_NIMCALL",
-    "N_STDCALL", "N_CDECL", "N_SAFECALL",
-    "N_SYSCALL", # this is probably not correct for all platforms,
-                 # but one can #define it to what one wants
-    "N_INLINE", "N_NOINLINE", "N_FASTCALL", "N_THISCALL", "N_CLOSURE", "N_NOCONV",
-    "N_NOCONV" #ccMember is N_NOCONV
-    ]
-
-proc procPtrTypeUnnamed(rettype, params: Snippet): Snippet =
-  rettype & "(*)" & params
-
-proc procPtrTypeUnnamedNimCall(rettype, params: Snippet): Snippet =
-  rettype & "(N_RAW_NIMCALL*)" & params
-
-proc cCast(typ, value: Snippet): Snippet =
-  "((" & typ & ") " & value & ")"
-
-proc wrapPar(value: Snippet): Snippet =
-  # used for expression group, no-op on sexp
-  "(" & value & ")"
-
-proc removeSinglePar(value: Snippet): Snippet =
-  # removes a single paren layer expected to exist, to silence Wparentheses-equality
-  assert value[0] == '(' and value[^1] == ')'
-  value[1..^2]
-
-template addCast(builder: var Builder, typ: Snippet, valueBody: typed) =
-  ## adds a cast to `typ` with value built by `valueBody`
-  builder.add "(("
-  builder.add typ
-  builder.add ") "
-  valueBody
-  builder.add ")"
-
-proc cAddr(value: Snippet): Snippet =
-  "&" & value
-
-proc cDeref(value: Snippet): Snippet =
-  "(*" & value & ")"
-
-proc subscript(a, b: Snippet): Snippet =
-  a & "[" & b & "]"
-
-proc dotField(a, b: Snippet): Snippet =
-  a & "." & b
-
-proc derefField(a, b: Snippet): Snippet =
-  a & "->" & b
-
-proc bitOr(a, b: Snippet): Snippet =
-  "(" & a & " | " & b & ")"
-
-type CallBuilder = object
-  needsComma: bool
-
-proc initCallBuilder(builder: var Builder, callee: Snippet): CallBuilder =
-  result = CallBuilder(needsComma: false)
-  builder.add(callee)
-  builder.add("(")
-
-template addArgument(builder: var Builder, call: var CallBuilder, valueBody: typed) =
-  if call.needsComma:
-    builder.add(", ")
-  else:
-    call.needsComma = true
-  valueBody
-
-proc finishCallBuilder(builder: var Builder, call: CallBuilder) =
-  builder.add(")")
-
-template addCall(builder: var Builder, call: out CallBuilder, callee: Snippet, body: typed) =
-  call = initCallBuilder(builder, callee)
-  body
-  finishCallBuilder(builder, call)
-
-proc addCall(builder: var Builder, callee: Snippet, args: varargs[Snippet]) =
-  builder.add(callee)
-  builder.add("(")
-  if args.len != 0:
-    builder.add(args[0])
-    for i in 1 ..< args.len:
-      builder.add(", ")
-      builder.add(args[i])
-  builder.add(")")
-
-proc cCall(callee: Snippet, args: varargs[Snippet]): Snippet =
-  result = callee
-  result.add("(")
-  if args.len != 0:
-    result.add(args[0])
-    for i in 1 ..< args.len:
-      result.add(", ")
-      result.add(args[i])
-  result.add(")")
-
-proc addSizeof(builder: var Builder, val: Snippet) =
-  builder.add("sizeof(")
-  builder.add(val)
-  builder.add(")")
-
-proc addAlignof(builder: var Builder, val: Snippet) =
-  builder.add("NIM_ALIGNOF(")
-  builder.add(val)
-  builder.add(")")
-
-proc addOffsetof(builder: var Builder, val, member: Snippet) =
-  builder.add("offsetof(")
-  builder.add(val)
-  builder.add(", ")
-  builder.add(member)
-  builder.add(")")
-
-template cSizeof(val: Snippet): Snippet =
-  "sizeof(" & val & ")"
-
-template cAlignof(val: Snippet): Snippet =
-  "NIM_ALIGNOF(" & val & ")"
-
-template cOffsetof(val, member: Snippet): Snippet =
-  "offsetof(" & val & ", " & member & ")"
-
-type TypedBinaryOp = enum
-  Add, Sub, Mul, Div, Mod
-  Shr, Shl, BitAnd, BitOr, BitXor
-
-const typedBinaryOperators: array[TypedBinaryOp, string] = [
-  Add: "+",
-  Sub: "-",
-  Mul: "*",
-  Div: "/",
-  Mod: "%",
-  Shr: ">>",
-  Shl: "<<",
-  BitAnd: "&",
-  BitOr: "|",
-  BitXor: "^"
-]
-
-type TypedUnaryOp = enum
-  Neg, BitNot
-
-const typedUnaryOperators: array[TypedUnaryOp, string] = [
-  Neg: "-",
-  BitNot: "~",
-]
-
-type UntypedBinaryOp = enum
-  LessEqual, LessThan, GreaterEqual, GreaterThan, Equal, NotEqual
-  And, Or
-
-const untypedBinaryOperators: array[UntypedBinaryOp, string] = [
-  LessEqual: "<=",
-  LessThan: "<",
-  GreaterEqual: ">=",
-  GreaterThan: ">",
-  Equal: "==",
-  NotEqual: "!=",
-  And: "&&",
-  Or: "||"
-]
-
-type UntypedUnaryOp = enum
-  Not
-
-const untypedUnaryOperators: array[UntypedUnaryOp, string] = [
-  Not: "!"
-]
-
-proc addOp(builder: var Builder, binOp: TypedBinaryOp, t: Snippet, a, b: Snippet) =
-  builder.add('(')
-  builder.add(a)
-  builder.add(' ')
-  builder.add(typedBinaryOperators[binOp])
-  builder.add(' ')
-  builder.add(b)
-  builder.add(')')
-
-proc addOp(builder: var Builder, unOp: TypedUnaryOp, t: Snippet, a: Snippet) =
-  builder.add('(')
-  builder.add(typedUnaryOperators[unOp])
-  builder.add('(')
-  builder.add(a)
-  builder.add("))")
-
-proc addOp(builder: var Builder, binOp: UntypedBinaryOp, a, b: Snippet) =
-  builder.add('(')
-  builder.add(a)
-  builder.add(' ')
-  builder.add(untypedBinaryOperators[binOp])
-  builder.add(' ')
-  builder.add(b)
-  builder.add(')')
-
-proc addOp(builder: var Builder, unOp: UntypedUnaryOp, a: Snippet) =
-  builder.add('(')
-  builder.add(untypedUnaryOperators[unOp])
-  builder.add('(')
-  builder.add(a)
-  builder.add("))")
-
-template cOp(binOp: TypedBinaryOp, t: Snippet, a, b: Snippet): Snippet =
-  '(' & a & ' ' & typedBinaryOperators[binOp] & ' ' & b & ')'
-
-template cOp(binOp: TypedUnaryOp, t: Snippet, a: Snippet): Snippet =
-  '(' & typedUnaryOperators[binOp] & '(' & a & "))"
-
-template cOp(binOp: UntypedBinaryOp, a, b: Snippet): Snippet =
-  '(' & a & ' ' & untypedBinaryOperators[binOp] & ' ' & b & ')'
-
-template cOp(binOp: UntypedUnaryOp, a: Snippet): Snippet =
-  '(' & untypedUnaryOperators[binOp] & '(' & a & "))"
-
-template cIfExpr(cond, a, b: Snippet): Snippet =
-  # XXX used for `min` and `max`, maybe add nifc primitives for these
-  "(" & cond & " ? " & a & " : " & b & ")"

compiler/cbuilderstmts.nim

@@ -1,150 +0,0 @@
-template addAssignmentWithValue(builder: var Builder, lhs: Snippet, valueBody: typed) =
-  builder.add(lhs)
-  builder.add(" = ")
-  valueBody
-  builder.add(";\n")
-
-template addFieldAssignmentWithValue(builder: var Builder, lhs: Snippet, name: string, valueBody: typed) =
-  builder.add(lhs)
-  builder.add("." & name & " = ")
-  valueBody
-  builder.add(";\n")
-
-template addAssignment(builder: var Builder, lhs, rhs: Snippet) =
-  builder.addAssignmentWithValue(lhs):
-    builder.add(rhs)
-
-template addFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: Snippet) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.add(rhs)
-
-template addMutualFieldAssignment(builder: var Builder, lhs, rhs: Snippet, name: string) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.add(rhs)
-    builder.add("." & name)
-
-template addAssignment(builder: var Builder, lhs: Snippet, rhs: int | int64 | uint64 | Int128) =
-  builder.addAssignmentWithValue(lhs):
-    builder.addIntValue(rhs)
-
-template addFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: int | int64 | uint64 | Int128) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.addIntValue(rhs)
-
-template addDerefFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: Snippet) =
-  builder.add(lhs)
-  builder.add("->" & name & " = ")
-  builder.add(rhs)
-  builder.add(";\n")
-
-template addSubscriptAssignment(builder: var Builder, lhs: Snippet, index: Snippet, rhs: Snippet) =
-  builder.add(lhs)
-  builder.add("[" & index & "] = ")
-  builder.add(rhs)
-  builder.add(";\n")
-
-template addStmt(builder: var Builder, stmtBody: typed) =
-  ## makes an expression built by `stmtBody` into a statement
-  stmtBody
-  builder.add(";\n")
-
-proc addCallStmt(builder: var Builder, callee: Snippet, args: varargs[Snippet]) =
-  builder.addStmt():
-    builder.addCall(callee, args)
-
-# XXX blocks need indent tracker in `Builder` object
-
-template addSingleIfStmt(builder: var Builder, cond: Snippet, body: typed) =
-  builder.add("if (")
-  builder.add(cond)
-  builder.add(") {\n")
-  body
-  builder.add("}\n")
-
-template addSingleIfStmtWithCond(builder: var Builder, condBody: typed, body: typed) =
-  builder.add("if (")
-  condBody
-  builder.add(") {\n")
-  body
-  builder.add("}\n")
-
-type IfStmt = object
-  needsElse: bool
-
-template addIfStmt(builder: var Builder, stmt: out IfStmt, body: typed) =
-  stmt = IfStmt(needsElse: false)
-  body
-  builder.add("\n")
-
-template addElifBranch(builder: var Builder, stmt: var IfStmt, cond: Snippet, body: typed) =
-  if stmt.needsElse:
-    builder.add(" else ")
-  else:
-    stmt.needsElse = true
-  builder.add("if (")
-  builder.add(cond)
-  builder.add(") {\n")
-  body
-  builder.add("}")
-
-template addElseBranch(builder: var Builder, stmt: var IfStmt, body: typed) =
-  assert stmt.needsElse
-  builder.add(" else {\n")
-  body
-  builder.add("}")
-
-proc addForRangeHeader(builder: var Builder, i, start, bound: Snippet, inclusive: bool = false) =
-  builder.add("for (")
-  builder.add(i)
-  builder.add(" = ")
-  builder.add(start)
-  builder.add("; ")
-  builder.add(i)
-  if inclusive:
-    builder.add(" <= ")
-  else:
-    builder.add(" < ")
-  builder.add(bound)
-  builder.add("; ")
-  builder.add(i)
-  builder.add("++) {\n")
-
-template addForRangeExclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  addForRangeHeader(builder, i, start, bound, false)
-  body
-  builder.add("}\n")
-
-template addForRangeInclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  addForRangeHeader(builder, i, start, bound, true)
-  body
-  builder.add("}\n")
-
-template addScope(builder: var Builder, body: typed) =
-  builder.add("{")
-  body
-  builder.add("\t}")
-
-proc addLabel(builder: var Builder, name: TLabel) =
-  builder.add(name)
-  builder.add(": ;\n")
-
-proc addReturn(builder: var Builder) =
-  builder.add("return;\n")
-
-proc addReturn(builder: var Builder, value: string) =
-  builder.add("return ")
-  builder.add(value)
-  builder.add(";\n")
-
-template addGoto(builder: var Builder, label: TLabel) =
-  builder.add("goto ")
-  builder.add(label)
-  builder.add(";\n")
-
-template addIncr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.add("++;\n")
-
-template addDecr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.add("--;\n")

compiler/ccgcalls.nim

@@ -76,23 +76,6 @@ proc isHarmlessStore(p: BProc; canRaise: bool; d: TLoc): bool =
   else:
     result = false
 
-proc cleanupTemp(p: BProc; returnType: PType, tmp: TLoc): bool =
-  if returnType.kind in {tyVar, tyLent}:
-    # we don't need to worry about var/lent return types
-    result = false
-  elif hasDestructor(returnType) and getAttachedOp(p.module.g.graph, returnType, attachedDestructor) != nil:
-    let dtor = getAttachedOp(p.module.g.graph, returnType, attachedDestructor)
-    var op = initLocExpr(p, newSymNode(dtor))
-    var callee = rdLoc(op)
-    let destroy = if dtor.typ.firstParamType.kind == tyVar:
-        callee & "(&" & rdLoc(tmp) & ")"
-      else:
-        callee & "(" & rdLoc(tmp) & ")"
-    raiseExitCleanup(p, destroy)
-    result = true
-  else:
-    result = false
-
 proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
                callee, params: Rope) =
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
@@ -100,17 +83,13 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
   var pl = callee & "(" & params
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
-  if typ.returnType != nil:
-    var flags: TAssignmentFlags = {}
-    if typ.returnType.kind in {tyOpenArray, tyVarargs}:
-      # perhaps generate no temp if the call doesn't have side effects
-      flags.incl needTempForOpenArray
+  if typ[0] != nil:
     if isInvalidReturnType(p.config, typ):
       if params.len != 0: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
-        if d.k == locNone: d = getTemp(p, typ.returnType, needsInit=true)
+        if d.k == locNone: d = getTemp(p, typ[0], needsInit=true)
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
@@ -118,7 +97,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
         pl.add(");\n")
         line(p, cpsStmts, pl)
       else:
-        var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
+        var tmp: TLoc = getTemp(p, typ[0], needsInit=true)
         pl.add(addrLoc(p.config, tmp))
         pl.add(");\n")
         line(p, cpsStmts, pl)
@@ -132,56 +111,43 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           # with them to prevent undefined behaviour and because the codegen
           # is free to emit expressions multiple times!
           d.k = locCall
-          d.snippet = pl
+          d.r = pl
           excl d.flags, lfSingleUse
         else:
           if d.k == locNone and p.splitDecls == 0:
-            d = getTempCpp(p, typ.returnType, pl)
+            d = getTempCpp(p, typ[0], pl)
           else:
-            if d.k == locNone: d = getTemp(p, typ.returnType)
+            if d.k == locNone: d = getTemp(p, typ[0])
             var list = initLoc(locCall, d.lode, OnUnknown)
-            list.snippet = pl
-            genAssignment(p, d, list, {needAssignCall}) # no need for deep copying
+            list.r = pl
+            genAssignment(p, d, list, {}) # no need for deep copying
             if canRaise: raiseExit(p)
 
       elif isHarmlessStore(p, canRaise, d):
-        var useTemp = false
-        if d.k == locNone:
-          useTemp = true
-          d = getTemp(p, typ.returnType)
+        if d.k == locNone: d = getTemp(p, typ[0])
         assert(d.t != nil)        # generate an assignment to d:
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
-        genAssignment(p, d, list, flags+{needAssignCall}) # no need for deep copying
-        if canRaise:
-          if not (useTemp and cleanupTemp(p, typ.returnType, d)):
-            raiseExit(p)
+        list.r = pl
+        genAssignment(p, d, list, {}) # no need for deep copying
+        if canRaise: raiseExit(p)
       else:
-        var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
+        var tmp: TLoc = getTemp(p, typ[0], needsInit=true)
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
-        genAssignment(p, tmp, list, flags+{needAssignCall}) # no need for deep copying
-        if canRaise:
-          if not cleanupTemp(p, typ.returnType, tmp):
-            raiseExit(p)
+        list.r = pl
+        genAssignment(p, tmp, list, {}) # no need for deep copying
+        if canRaise: raiseExit(p)
         genAssignment(p, d, tmp, {})
   else:
     pl.add(");\n")
     line(p, cpsStmts, pl)
     if canRaise: raiseExit(p)
 
-proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType)
+proc genBoundsCheck(p: BProc; arr, a, b: TLoc)
 
 proc reifiedOpenArray(n: PNode): bool {.inline.} =
   var x = n
-  while true:
-    case x.kind
-    of {nkAddr, nkHiddenAddr, nkHiddenDeref}:
-      x = x[0]
-    of nkHiddenStdConv:
-      x = x[1]
-    else:
-      break
+  while x.kind in {nkAddr, nkHiddenAddr, nkHiddenStdConv, nkHiddenDeref}:
+    x = x[0]
   if x.kind == nkSym and x.sym.kind == skParam:
     result = false
   else:
@@ -191,15 +157,12 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   var a = initLocExpr(p, q[1])
   var b = initLocExpr(p, q[2])
   var c = initLocExpr(p, q[3])
-  # bug #23321: In the function mapType, ptrs (tyPtr, tyVar, tyLent, tyRef)
-  # are mapped into ctPtrToArray, the dereference of which is skipped
-  # in the `genDeref`. We need to skip these ptrs here
-  let ty = skipTypes(a.t, abstractVar+{tyPtr, tyRef})
   # but first produce the required index checks:
   if optBoundsCheck in p.options:
-    genBoundsCheck(p, a, b, c, ty)
+    genBoundsCheck(p, a, b, c)
   if prepareForMutation:
     linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
+  let ty = skipTypes(a.t, abstractVar+{tyPtr})
   let dest = getTypeDesc(p.module, destType)
   let lengthExpr = "($1)-($2)+1" % [rdLoc(c), rdLoc(b)]
   case ty.kind
@@ -209,7 +172,8 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
       result = ("($3*)(($1)+($2))" % [rdLoc(a), rdLoc(b), dest],
                 lengthExpr)
     else:
-      let lit = cIntLiteral(first)
+      var lit = newRopeAppender()
+      intLiteral(first, lit)
       result = ("($4*)($1)+(($2)-($3))" %
         [rdLoc(a), rdLoc(b), lit, dest],
         lengthExpr)
@@ -230,11 +194,11 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
       linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
     if atyp.kind in {tyVar} and not compileToCpp(p.module):
       result = ("(($5) ? (($4*)(*$1)$3+($2)) : NIM_NIL)" %
-                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, "*" & rdLoc(a))],
+                  [rdLoc(a), rdLoc(b), dataField(p, ty.kind == tyString), dest, dataFieldAccessor(p, "*" & rdLoc(a))],
                 lengthExpr)
     else:
       result = ("(($5) ? (($4*)$1$3+($2)) : NIM_NIL)" %
-                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, rdLoc(a))],
+                  [rdLoc(a), rdLoc(b), dataField(p, ty.kind == tyString), dest, dataFieldAccessor(p, rdLoc(a))],
                 lengthExpr)
   else:
     result = ("", "")
@@ -254,11 +218,12 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
         for i in 0..<q.len-1:
           genStmts(p, q[i])
         q = q.lastSon
-    let (x, y) = genOpenArraySlice(p, q, formalType, n.typ.elementType)
+    let (x, y) = genOpenArraySlice(p, q, formalType, n.typ[0])
     result.add x & ", " & y
   else:
     var a = initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n)
-    case skipTypes(a.t, abstractVar+{tyStatic}).kind
+    let typKind = skipTypes(a.t, abstractVar+{tyStatic}).kind
+    case typKind
     of tyOpenArray, tyVarargs:
       if reifiedOpenArray(n):
         if a.t.kind in {tyVar, tyLent}:
@@ -273,24 +238,26 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
           optSeqDestructors in p.config.globalOptions:
         linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
       if ntyp.kind in {tyVar} and not compileToCpp(p.module):
-        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        var t: TLoc
+        t.r = "(*$1)" % [a.rdLoc]
         result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                     [a.rdLoc, lenExpr(p, t, typKind == tyString), dataField(p, typKind == tyString),
                       dataFieldAccessor(p, "*" & a.rdLoc)]
       else:
         result.add "($4) ? ($1$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, a), dataField(p), dataFieldAccessor(p, a.rdLoc)]
+                     [a.rdLoc, lenExpr(p, a, typKind == tyString), dataField(p, typKind == tyString), dataFieldAccessor(p, a.rdLoc)]
     of tyArray:
       result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, a.t))]
     of tyPtr, tyRef:
-      case elementType(a.t).kind
+      case lastSon(a.t).kind
       of tyString, tySequence:
-        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        var t: TLoc
+        t.r = "(*$1)" % [a.rdLoc]
         result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
-                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                     [a.rdLoc, lenExpr(p, t, typKind == tyString), dataField(p, typKind == tyString),
                       dataFieldAccessor(p, "*" & a.rdLoc)]
       of tyArray:
-        result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, elementType(a.t)))]
+        result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, lastSon(a.t)))]
       else:
         internalError(p.config, "openArrayLoc: " & typeToString(a.t))
     else: internalError(p.config, "openArrayLoc: " & typeToString(a.t))
@@ -321,7 +288,7 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
   elif skipTypes(param.typ, abstractVar).kind in {tyOpenArray, tyVarargs}:
     var n = if n.kind != nkHiddenAddr: n else: n[0]
     openArrayLoc(p, param.typ, n, result)
-  elif ccgIntroducedPtr(p.config, param, call[0].typ.returnType) and
+  elif ccgIntroducedPtr(p.config, param, call[0].typ[0]) and
     (optByRef notin param.options or not p.module.compileToCpp):
     a = initLocExpr(p, n)
     if n.kind in {nkCharLit..nkNilLit}:
@@ -330,33 +297,18 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; need
       addAddrLoc(p.config, withTmpIfNeeded(p, a, needsTmp), result)
   elif p.module.compileToCpp and param.typ.kind in {tyVar} and
       n.kind == nkHiddenAddr:
-    # bug #23748: we need to introduce a temporary here. The expression type
-    # will be a reference in C++ and we cannot create a temporary reference
-    # variable. Thus, we create a temporary pointer variable instead.
-    let needsIndirect = mapType(p.config, n[0].typ, mapTypeChooser(n[0]) == skParam) != ctArray
-    if needsIndirect:
-      n.typ() = n.typ.exactReplica
-      n.typ.flags.incl tfVarIsPtr
-    a = initLocExprSingleUse(p, n)
-    a = withTmpIfNeeded(p, a, needsTmp)
-    if needsIndirect: a.flags.incl lfIndirect
+    a = initLocExprSingleUse(p, n[0])
     # if the proc is 'importc'ed but not 'importcpp'ed then 'var T' still
     # means '*T'. See posix.nim for lots of examples that do that in the wild.
     let callee = call[0]
     if callee.kind == nkSym and
         {sfImportc, sfInfixCall, sfCompilerProc} * callee.sym.flags == {sfImportc} and
-        {lfHeader, lfNoDecl} * callee.sym.loc.flags != {} and
-        needsIndirect:
+        {lfHeader, lfNoDecl} * callee.sym.loc.flags != {}:
       addAddrLoc(p.config, a, result)
     else:
       addRdLoc(a, result)
   else:
     a = initLocExprSingleUse(p, n)
-    if param.typ.kind in {tyVar, tyPtr, tyRef, tySink}:
-      let typ = skipTypes(param.typ, abstractPtrs)
-      if not sameBackendTypePickyAliases(typ, n.typ.skipTypes(abstractPtrs)):
-        a.snippet = "(($1) ($2))" %
-          [getTypeDesc(p.module, param.typ), rdCharLoc(a)]
     addRdLoc(withTmpIfNeeded(p, a, needsTmp), result)
   #assert result != nil
 
@@ -401,7 +353,7 @@ proc getPotentialWrites(n: PNode; mutate: bool; result: var seq[PNode]) =
   of nkCallKinds:
     case n.getMagic:
     of mIncl, mExcl, mInc, mDec, mAppendStrCh, mAppendStrStr, mAppendSeqElem,
-        mAddr, mNew, mNewFinalize, mWasMoved, mDestroy:
+        mAddr, mNew, mNewFinalize, mWasMoved, mDestroy, mReset:
       getPotentialWrites(n[1], true, result)
       for i in 2..<n.len:
         getPotentialWrites(n[i], mutate, result)
@@ -439,15 +391,13 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
         if not needTmp[i - 1]:
           needTmp[i - 1] = potentialAlias(n, potentialWrites)
       getPotentialWrites(ri[i], false, potentialWrites)
-    when false:
-      # this optimization is wrong, see bug #23748
-      if ri[i].kind in {nkHiddenAddr, nkAddr}:
-        # Optimization: don't use a temp, if we would only take the address anyway
-        needTmp[i - 1] = false
+    if ri[i].kind in {nkHiddenAddr, nkAddr}:
+      # Optimization: don't use a temp, if we would only take the address anyway
+      needTmp[i - 1] = false
 
   var oldLen = result.len
   for i in 1..<ri.len:
-    if i < typ.n.len:
+    if i < typ.len:
       assert(typ.n[i].kind == nkSym)
       let paramType = typ.n[i]
       if not paramType.typ.isCompileTimeOnly:
@@ -472,6 +422,7 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
+  assert(typ.len == typ.n.len)
 
   var params = newRopeAppender()
   genParams(p, ri, typ, params)
@@ -494,6 +445,7 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
+  assert(typ.len == typ.n.len)
 
   var pl = newRopeAppender()
   genParams(p, ri, typ, pl)
@@ -506,14 +458,14 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
   let rawProc = getClosureType(p.module, typ, clHalf)
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
-  if typ.returnType != nil:
+  if typ[0] != nil:
     if isInvalidReturnType(p.config, typ):
       if ri.len > 1: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
         if d.k == locNone:
-          d = getTemp(p, typ.returnType, needsInit=true)
+          d = getTemp(p, typ[0], needsInit=true)
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
@@ -521,29 +473,29 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         genCallPattern()
         if canRaise: raiseExit(p)
       else:
-        var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
+        var tmp: TLoc = getTemp(p, typ[0], needsInit=true)
         pl.add(addrLoc(p.config, tmp))
         genCallPattern()
         if canRaise: raiseExit(p)
         genAssignment(p, d, tmp, {}) # no need for deep copying
     elif isHarmlessStore(p, canRaise, d):
-      if d.k == locNone: d = getTemp(p, typ.returnType)
+      if d.k == locNone: d = getTemp(p, typ[0])
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
       if tfIterator in typ.flags:
-        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.r = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.r = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
       genAssignment(p, d, list, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
-      var tmp: TLoc = getTemp(p, typ.returnType)
+      var tmp: TLoc = getTemp(p, typ[0])
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
       if tfIterator in typ.flags:
-        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.r = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
+        list.r = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
       genAssignment(p, tmp, list, {})
       if canRaise: raiseExit(p)
       genAssignment(p, d, tmp, {})
@@ -553,14 +505,14 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
 proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope;
                  argsCounter: var int) =
-  if i < typ.n.len:
+  if i < typ.len:
     # 'var T' is 'T&' in C++. This means we ignore the request of
     # any nkHiddenAddr when it's a 'var T'.
     let paramType = typ.n[i]
     assert(paramType.kind == nkSym)
     if paramType.typ.isCompileTimeOnly:
       discard
-    elif paramType.typ.kind in {tyVar} and ri[i].kind == nkHiddenAddr:
+    elif typ[i].kind in {tyVar} and ri[i].kind == nkHiddenAddr:
       if argsCounter > 0: result.add ", "
       genArgNoParam(p, ri[i][0], result)
       inc argsCounter
@@ -635,7 +587,7 @@ proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope) =
   # for better or worse c2nim translates the 'this' argument to a 'var T'.
   # However manual wrappers may also use 'ptr T'. In any case we support both
   # for convenience.
-  internalAssert p.config, i < typ.n.len
+  internalAssert p.config, i < typ.len
   assert(typ.n[i].kind == nkSym)
   # if the parameter is lying (tyVar) and thus we required an additional deref,
   # skip the deref:
@@ -725,27 +677,28 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   assert(typ.kind == tyProc)
+  assert(typ.len == typ.n.len)
   # don't call '$' here for efficiency:
-  let pat = $ri[0].sym.loc.snippet
+  let pat = $ri[0].sym.loc.r
   internalAssert p.config, pat.len > 0
   if pat.contains({'#', '(', '@', '\''}):
     var pl = newRopeAppender()
     genPatternCall(p, ri, pat, typ, pl)
     # simpler version of 'fixupCall' that works with the pl+params combination:
     var typ = skipTypes(ri[0].typ, abstractInst)
-    if typ.returnType != nil:
+    if typ[0] != nil:
       if p.module.compileToCpp and lfSingleUse in d.flags:
         # do not generate spurious temporaries for C++! For C we're better off
         # with them to prevent undefined behaviour and because the codegen
         # is free to emit expressions multiple times!
         d.k = locCall
-        d.snippet = pl
+        d.r = pl
         excl d.flags, lfSingleUse
       else:
-        if d.k == locNone: d = getTemp(p, typ.returnType)
+        if d.k == locNone: d = getTemp(p, typ[0])
         assert(d.t != nil)        # generate an assignment to d:
         var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = pl
+        list.r = pl
         genAssignment(p, d, list, {}) # no need for deep copying
     else:
       pl.add(";\n")
@@ -755,9 +708,10 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
     var argsCounter = 0
     if 1 < ri.len:
       genThisArg(p, ri, 1, typ, pl)
-    pl.add(op.snippet)
+    pl.add(op.r)
     var params = newRopeAppender()
     for i in 2..<ri.len:
+      assert(typ.len == typ.n.len)
       genOtherArg(p, ri, i, typ, params, argsCounter)
     fixupCall(p, le, ri, d, pl, params)
 
@@ -768,14 +722,15 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   assert(typ.kind == tyProc)
+  assert(typ.len == typ.n.len)
 
   # don't call '$' here for efficiency:
-  let pat = $ri[0].sym.loc.snippet
+  let pat = $ri[0].sym.loc.r
   internalAssert p.config, pat.len > 0
   var start = 3
   if ' ' in pat:
     start = 1
-    pl.add(op.snippet)
+    pl.add(op.r)
     if ri.len > 1:
       pl.add(": ")
       genArg(p, ri[1], typ.n[1].sym, ri, pl)
@@ -784,12 +739,13 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
     if ri.len > 1:
       genArg(p, ri[1], typ.n[1].sym, ri, pl)
       pl.add(" ")
-    pl.add(op.snippet)
+    pl.add(op.r)
     if ri.len > 2:
       pl.add(": ")
       genArg(p, ri[2], typ.n[2].sym, ri, pl)
   for i in start..<ri.len:
-    if i >= typ.n.len:
+    assert(typ.len == typ.n.len)
+    if i >= typ.len:
       internalError(p.config, ri.info, "varargs for objective C method?")
     assert(typ.n[i].kind == nkSym)
     var param = typ.n[i].sym
@@ -797,29 +753,29 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
     pl.add(param.name.s)
     pl.add(": ")
     genArg(p, ri[i], param, ri, pl)
-  if typ.returnType != nil:
+  if typ[0] != nil:
     if isInvalidReturnType(p.config, typ):
       if ri.len > 1: pl.add(" ")
       # beware of 'result = p(result)'. We always allocate a temporary:
       if d.k in {locTemp, locNone}:
         # We already got a temp. Great, special case it:
-        if d.k == locNone: d = getTemp(p, typ.returnType, needsInit=true)
+        if d.k == locNone: d = getTemp(p, typ[0], needsInit=true)
         pl.add("Result: ")
         pl.add(addrLoc(p.config, d))
         pl.add("];\n")
         line(p, cpsStmts, pl)
       else:
-        var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
+        var tmp: TLoc = getTemp(p, typ[0], needsInit=true)
         pl.add(addrLoc(p.config, tmp))
         pl.add("];\n")
         line(p, cpsStmts, pl)
         genAssignment(p, d, tmp, {}) # no need for deep copying
     else:
       pl.add("]")
-      if d.k == locNone: d = getTemp(p, typ.returnType)
+      if d.k == locNone: d = getTemp(p, typ[0])
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, ri, OnUnknown)
-      list.snippet = pl
+      list.r = pl
       genAssignment(p, d, list, {}) # no need for deep copying
   else:
     pl.add("];\n")

compiler/ccgliterals.nim

@@ -36,84 +36,52 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
   cgsym(m, "TGenericSeq")
   let tmp = getTempName(m)
   result.add tmp
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(AlwaysConst, name = tmp):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "Sup", typ = "TGenericSeq")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
-  do:
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "Sup"):
-        var seqInit: StructInitializer
-        res.addStructInitializer(seqInit, kind = siOrderedStruct):
-          res.addField(seqInit, name = "len"):
-            res.addIntValue(s.len)
-          res.addField(seqInit, name = "reserved"):
-            res.add(cCast("NI", bitOr(cCast("NU", rope(s.len)), "NIM_STRLIT_FLAG")))
-      res.addField(strInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("STRING_LITERAL($1, $2, $3);$n",
+       [tmp, makeCString(s), rope(s.len)])
 
-proc genStringLiteralV1(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteralV1(m: BModule; n: PNode; result: var Rope) =
   if s.isNil:
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
+    appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
   else:
     let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-    var name: string = ""
     if id == m.labels:
       # string literal not found in the cache:
-      genStringLiteralDataOnlyV1(m, n.strVal, name)
+      appcg(m, result, "((#NimStringDesc*) &", [])
+      genStringLiteralDataOnlyV1(m, n.strVal, result)
+      result.add ")"
     else:
-      name = m.tmpBase & $id
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), cAddr(name)))
+      appcg(m, result, "((#NimStringDesc*) &$1$2)",
+                      [m.tmpBase, id])
 
 # ------ Version 2: destructor based strings and seqs -----------------------
 
 proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bool) =
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = result):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "cap", typ = "NI")
-      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
-  do:
-    var structInit: StructInitializer
-    res.addStructInitializer(structInit, kind = siOrderedStruct):
-      res.addField(structInit, name = "cap"):
-        res.add(bitOr(rope(s.len), "NIM_STRLIT_FLAG"))
-      res.addField(structInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("static $4 struct {$n" &
+       "  NI cap; NIM_CHAR data[$2+1];$n" &
+       "} $1 = { $2 | NIM_STRLIT_FLAG, $3 };$n",
+       [result, rope(s.len), makeCString(s),
+       rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-  var litName: string
   if id == m.labels:
+    let pureLit = getTempName(m)
+    genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
+    let tmp = getTempName(m)
+    result.add tmp
     cgsym(m, "NimStrPayload")
     cgsym(m, "NimStringV2")
     # string literal not found in the cache:
-    litName = getTempName(m)
-    genStringLiteralDataOnlyV2(m, n.strVal, litName, isConst)
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), pureLit, rope(if isConst: "const" else: "")])
   else:
-    litName = m.tmpBase & $id
-  let tmp = getTempName(m)
-  result.add tmp
-  var res = newBuilder("")
-  res.addVarWithInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = tmp,
-      typ = "NimStringV2"):
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "len"):
-        res.addIntValue(n.strVal.len)
-      res.addField(strInit, name = "p"):
-        res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
-  m.s[cfsStrData].add(extract(res))
+    let tmp = getTempName(m)
+    result.add tmp
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), m.tmpBase & rope(id),
+          rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
   var pureLit: Rope
   if id == m.labels:
@@ -124,12 +92,49 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Bu
     genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
   else:
     pureLit = m.tmpBase & rope(id)
-  var strInit: StructInitializer
-  result.addStructInitializer(strInit, kind = siOrderedStruct):
-    result.addField(strInit, name = "len"):
-      result.addIntValue(n.strVal.len)
-    result.addField(strInit, name = "p"):
-      result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
+  result.addf "{$1, (NimStrPayload*)&$2}", [rope(n.strVal.len), pureLit]
+
+# ------ Version 3: destructor based strings and seqs -----------------------
+# strings are enhanced by interned strings
+
+proc toConstLenV3(len: int): string =
+  result = rope((len shl 1) or 1)
+
+proc genStringLiteralDataOnlyV3(m: BModule, s: string; result: Rope; isConst: bool) =
+  # TODO: fixme: perhaps use makeCString for clarity for C
+  m.s[cfsStrData].addf("static $4 NIM_CHAR $1[$2] = $3;$n",
+       [result, rope(s.len), makeCCharArray(s),
+       rope(if isConst: "const" else: "")])
+
+proc genStringLiteralV3(m: BModule; n: PNode; isConst: bool; result: var Rope) =
+  let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
+  if id == m.labels:
+    let pureLit = getTempName(m)
+    genStringLiteralDataOnlyV3(m, n.strVal, pureLit, isConst)
+    let tmp = getTempName(m)
+    result.add tmp
+    cgsym(m, "NimStringV3")
+    # string literal not found in the cache:
+    m.s[cfsStrData].addf("static $4 NimStringV3 $1 = {$2, (NIM_CHAR*)&$3};$n",
+          [tmp, toConstLenV3(n.strVal.len), pureLit, rope(if isConst: "const" else: "")])
+  else:
+    let tmp = getTempName(m)
+    result.add tmp
+    m.s[cfsStrData].addf("static $4 NimStringV3 $1 = {$2, (NIM_CHAR*)&$3};$n",
+          [tmp, toConstLenV3(n.strVal.len), m.tmpBase & rope(id),
+          rope(if isConst: "const" else: "")])
+
+proc genStringLiteralV3Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
+  let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
+  var pureLit: Rope
+  if id == m.labels:
+    pureLit = getTempName(m)
+    cgsym(m, "NimStringV3")
+    # string literal not found in the cache:
+    genStringLiteralDataOnlyV3(m, n.strVal, pureLit, isConst)
+  else:
+    pureLit = m.tmpBase & rope(id)
+  result.addf "{$1, (NIM_CHAR*)&$2}", [toConstLenV3(n.strVal.len), pureLit]
 
 # ------ Version selector ---------------------------------------------------
 
@@ -141,15 +146,20 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
     let tmp = getTempName(m)
     genStringLiteralDataOnlyV2(m, s, tmp, isConst)
     result.add tmp
+  of 3:
+    let tmp = getTempName(m)
+    genStringLiteralDataOnlyV3(m, s, tmp, isConst)
+    result.add tmp
   else:
     localError(m.config, info, "cannot determine how to produce code for string literal")
 
-proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Builder) =
-  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
+proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
+  appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
 
-proc genStringLiteral(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteral(m: BModule; n: PNode; result: var Rope) =
   case detectStrVersion(m)
   of 0, 1: genStringLiteralV1(m, n, result)
   of 2: genStringLiteralV2(m, n, isConst = true, result)
+  of 3: genStringLiteralV3(m, n, isConst = true, result)
   else:
     localError(m.config, n.info, "cannot determine how to produce code for string literal")

compiler/ccgreset.nim

@@ -24,10 +24,10 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
   of nkRecCase:
     if (n[0].kind != nkSym): internalError(p.config, n.info, "specializeResetN")
     let disc = n[0].sym
-    if disc.loc.snippet == "": fillObjectFields(p.module, typ)
+    if disc.loc.r == "": fillObjectFields(p.module, typ)
     if disc.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.r])
     for i in 1..<n.len:
       let branch = n[i]
       assert branch.kind in {nkOfBranch, nkElse}
@@ -38,14 +38,14 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
       specializeResetN(p, accessor, lastSon(branch), typ)
       lineF(p, cpsStmts, "break;$n", [])
     lineF(p, cpsStmts, "} $n", [])
-    specializeResetT(p, "$1.$2" % [accessor, disc.loc.snippet], disc.loc.t)
+    specializeResetT(p, "$1.$2" % [accessor, disc.loc.r], disc.loc.t)
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
-    if field.loc.snippet == "": fillObjectFields(p.module, typ)
+    if field.loc.r == "": fillObjectFields(p.module, typ)
     if field.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    specializeResetT(p, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
+    specializeResetT(p, "$1.$2" % [accessor, field.loc.r], field.loc.t)
   else: internalError(p.config, n.info, "specializeResetN()")
 
 proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
@@ -54,23 +54,24 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
   case typ.kind
   of tyGenericInst, tyGenericBody, tyTypeDesc, tyAlias, tyDistinct, tyInferred,
      tySink, tyOwned:
-    specializeResetT(p, accessor, skipModifier(typ))
+    specializeResetT(p, accessor, lastSon(typ))
   of tyArray:
-    let arraySize = lengthOrd(p.config, typ.indexType)
+    let arraySize = lengthOrd(p.config, typ[0])
     var i: TLoc = getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt))
     linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
-            [i.snippet, arraySize])
-    specializeResetT(p, ropecg(p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
+            [i.r, arraySize])
+    specializeResetT(p, ropecg(p.module, "$1[$2]", [accessor, i.r]), typ[1])
     lineF(p, cpsStmts, "}$n", [])
   of tyObject:
-    var x = typ.baseClass
-    if x != nil: x = x.skipTypes(skipPtrs)
-    specializeResetT(p, accessor.parentObj(p.module), x)
+    for i in 0..<typ.len:
+      var x = typ[i]
+      if x != nil: x = x.skipTypes(skipPtrs)
+      specializeResetT(p, accessor.parentObj(p.module), x)
     if typ.n != nil: specializeResetN(p, accessor, typ.n, typ)
   of tyTuple:
     let typ = getUniqueType(typ)
-    for i, a in typ.ikids:
-      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), a)
+    for i in 0..<typ.len:
+      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), typ[i])
 
   of tyString, tyRef, tySequence:
     lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1, NIM_NIL);$n", [accessor])
@@ -81,7 +82,7 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
       lineCg(p, cpsStmts, "$1.ClP_0 = NIM_NIL;$n", [accessor])
     else:
       lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
-  of tyChar, tyBool, tyEnum, tyRange, tyInt..tyUInt64:
+  of tyChar, tyBool, tyEnum, tyInt..tyUInt64:
     lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
   of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
     lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
@@ -95,8 +96,8 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
     else:
       raiseAssert "unexpected set type kind"
   of tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,
-      tyGenericParam, tyOrdinal, tyOpenArray, tyForward, tyVarargs,
-      tyUncheckedArray, tyError, tyBuiltInTypeClass, tyUserTypeClass,
+      tyGenericParam, tyOrdinal, tyRange, tyOpenArray, tyForward, tyVarargs,
+      tyUncheckedArray, tyProxy, tyBuiltInTypeClass, tyUserTypeClass,
       tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot,
       tyAnything, tyStatic, tyFromExpr, tyConcept, tyVoid, tyIterable:
     discard

compiler/ccgstmts.nim

@@ -110,10 +110,10 @@ proc genVarTuple(p: BProc, n: PNode) =
       initLocalVar(p, v, immediateAsgn=isAssignedImmediately(p.config, n[^1]))
     var field = initLoc(locExpr, vn, tup.storage)
     if t.kind == tyTuple:
-      field.snippet = "$1.Field$2" % [rdLoc(tup), rope(i)]
+      field.r = "$1.Field$2" % [rdLoc(tup), rope(i)]
     else:
       if t.n[i].kind != nkSym: internalError(p.config, n.info, "genVarTuple")
-      field.snippet = "$1.$2" % [rdLoc(tup), mangleRecFieldName(p.module, t.n[i].sym)]
+      field.r = "$1.$2" % [rdLoc(tup), mangleRecFieldName(p.module, t.n[i].sym)]
     putLocIntoDest(p, v.loc, field)
     if forHcr or isGlobalInBlock:
       hcrGlobals.add((loc: v.loc, tp: "NULL"))
@@ -128,7 +128,7 @@ proc genVarTuple(p: BProc, n: PNode) =
     lineCg(p, cpsLocals, "NIM_BOOL $1 = NIM_FALSE;$n", [hcrCond])
     for curr in hcrGlobals:
       lineCg(p, cpsLocals, "$1 |= hcrRegisterGlobal($4, \"$2\", sizeof($3), $5, (void**)&$2);$N",
-              [hcrCond, curr.loc.snippet, rdLoc(curr.loc), getModuleDllPath(p.module, n[0].sym), curr.tp])
+              [hcrCond, curr.loc.r, rdLoc(curr.loc), getModuleDllPath(p.module, n[0].sym), curr.tp])
 
 
 proc loadInto(p: BProc, le, ri: PNode, a: var TLoc) {.inline.} =
@@ -146,16 +146,16 @@ proc loadInto(p: BProc, le, ri: PNode, a: var TLoc) {.inline.} =
     a.flags.incl(lfEnforceDeref)
     expr(p, ri, a)
 
-proc assignLabel(b: var TBlock; result: var Builder) {.inline.} =
+proc assignLabel(b: var TBlock; result: var Rope) {.inline.} =
   b.label = "LA" & b.id.rope
   result.add b.label
 
-proc blockBody(b: var TBlock; result: var Builder) =
-  result.add extract(b.sections[cpsLocals])
+proc blockBody(b: var TBlock; result: var Rope) =
+  result.add b.sections[cpsLocals]
   if b.frameLen > 0:
     result.addf("FR_.len+=$1;$n", [b.frameLen.rope])
-  result.add(extract(b.sections[cpsInit]))
-  result.add(extract(b.sections[cpsStmts]))
+  result.add(b.sections[cpsInit])
+  result.add(b.sections[cpsStmts])
 
 proc endBlock(p: BProc, blockEnd: Rope) =
   let topBlock = p.blocks.len-1
@@ -267,11 +267,11 @@ proc genBreakState(p: BProc, n: PNode, d: var TLoc) =
 
   if n[0].kind == nkClosure:
     a = initLocExpr(p, n[0][1])
-    d.snippet = "(((NI*) $1)[1] < 0)" % [rdLoc(a)]
+    d.r = "(((NI*) $1)[1] < 0)" % [rdLoc(a)]
   else:
     a = initLocExpr(p, n[0])
     # the environment is guaranteed to contain the 'state' field at offset 1:
-    d.snippet = "((((NI*) $1.ClE_0)[1]) < 0)" % [rdLoc(a)]
+    d.r = "((((NI*) $1.ClE_0)[1]) < 0)" % [rdLoc(a)]
 
 proc genGotoVar(p: BProc; value: PNode) =
   if value.kind notin {nkCharLit..nkUInt64Lit}:
@@ -279,9 +279,9 @@ proc genGotoVar(p: BProc; value: PNode) =
   else:
     lineF(p, cpsStmts, "goto NIMSTATE_$#;$n", [value.intVal.rope])
 
-proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Builder)
+proc genBracedInit(p: BProc, n: PNode; isConst: bool; optionalType: PType; result: var Rope)
 
-proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Builder) =
+proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Rope) =
   if lfDynamicLib in v.loc.flags or sfThread in v.flags or p.hcrOn:
     discard "nothing to do"
   elif sfGlobal in v.flags and value != nil and isDeepConstExpr(value, p.module.compileToCpp) and
@@ -289,32 +289,22 @@ proc potentialValueInit(p: BProc; v: PSym; value: PNode; result: var Builder) =
     #echo "New code produced for ", v.name.s, " ", p.config $ value.info
     genBracedInit(p, value, isConst = false, v.typ, result)
 
-proc genCppParamsForCtor(p: BProc; call: PNode; didGenTemp: var bool): string =
+proc genCppParamsForCtor(p: BProc; call: PNode): string = 
   result = ""
   var argsCounter = 0
   let typ = skipTypes(call[0].typ, abstractInst)
   assert(typ.kind == tyProc)
   for i in 1..<call.len:
+    assert(typ.len == typ.n.len)
     #if it's a type we can just generate here another initializer as we are in an initializer context
     if call[i].kind == nkCall and call[i][0].kind == nkSym and call[i][0].sym.kind == skType:
       if argsCounter > 0: result.add ","
-      result.add genCppInitializer(p.module, p, call[i][0].sym.typ, didGenTemp)
+      result.add genCppInitializer(p.module, p, call[i][0].sym.typ)
     else:
-      #We need to test for temp in globals, see: #23657
-      let param =
-        if typ[i].kind in {tyVar} and call[i].kind == nkHiddenAddr:
-          call[i][0]
-        else:
-          call[i]
-      if param.kind != nkBracketExpr or param.typ.kind in
-        {tyRef, tyPtr, tyUncheckedArray, tyArray, tyOpenArray,
-          tyVarargs, tySequence, tyString, tyCstring, tyTuple}:
-        let tempLoc = initLocExprSingleUse(p, param)
-        didGenTemp = didGenTemp or tempLoc.k == locTemp
       genOtherArg(p, call, i, typ, result, argsCounter)
 
-proc genCppVarForCtor(p: BProc; call: PNode; decl: var Rope, didGenTemp: var bool) =
-  let params = genCppParamsForCtor(p, call, didGenTemp)
+proc genCppVarForCtor(p: BProc; call: PNode; decl: var Rope) =
+  let params = genCppParamsForCtor(p, call)
   if params.len == 0:
     decl = runtimeFormat("$#;\n", [decl])
   else:
@@ -330,9 +320,8 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
     value.kind in nkCallKinds and value[0].kind == nkSym and
     v.typ.kind != tyPtr and sfConstructor in value[0].sym.flags
   var targetProc = p
-  var valueBuilder = newBuilder("")
-  potentialValueInit(p, v, value, valueBuilder)
-  let valueAsRope = extract(valueBuilder)
+  var valueAsRope = ""
+  potentialValueInit(p, v, value, valueAsRope)
   if sfGlobal in v.flags:
     if v.flags * {sfImportc, sfExportc} == {sfImportc} and
         value.kind == nkEmpty and
@@ -342,14 +331,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
       # v.owner.kind != skModule:
       targetProc = p.module.preInitProc
     if isCppCtorCall and not containsHiddenPointer(v.typ):
-      var didGenTemp = false
-      callGlobalVarCppCtor(targetProc, v, vn, value, didGenTemp)
-      if didGenTemp:
-        message(p.config, vn.info, warnGlobalVarConstructorTemporary, vn.sym.name.s)
-        #We fail to call the constructor in the global scope so we do the call inside the main proc
-        assignGlobalVar(targetProc, vn, valueAsRope)
-        var loc = initLocExprSingleUse(targetProc, value)
-        genAssignment(targetProc, v.loc, loc, {})
+      callGlobalVarCppCtor(targetProc, v, vn, value)
     else:
       assignGlobalVar(targetProc, vn, valueAsRope)
 
@@ -384,15 +366,11 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
       var decl = localVarDecl(p, vn)
       var tmp: TLoc
       if isCppCtorCall:
-        var didGenTemp = false
-        genCppVarForCtor(p, value, decl, didGenTemp)
+        genCppVarForCtor(p, value, decl)
         line(p, cpsStmts, decl)
       else:
         tmp = initLocExprSingleUse(p, value)
-        if value.kind == nkEmpty:
-          lineF(p, cpsStmts, "$#;\n", [decl])
-        else:
-          lineF(p, cpsStmts, "$# = $#;\n", [decl, tmp.rdLoc])
+        lineF(p, cpsStmts, "$# = $#;\n", [decl, tmp.rdLoc])
       return
     assignLocalVar(p, vn)
     initLocalVar(p, v, imm)
@@ -406,7 +384,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
     # put it in the locals section - mainly because of loops which
     # use the var in a call to resetLoc() in the statements section
     lineCg(targetProc, cpsLocals, "hcrRegisterGlobal($3, \"$1\", sizeof($2), $4, (void**)&$1);$n",
-           [v.loc.snippet, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
+           [v.loc.r, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
     # nothing special left to do later on - let's avoid closing and reopening blocks
     forHcr = false
 
@@ -415,7 +393,7 @@ proc genSingleVar(p: BProc, v: PSym; vn, value: PNode) =
   # be able to re-run it but without the top level code - just the init of globals
   if forHcr:
     lineCg(targetProc, cpsStmts, "if (hcrRegisterGlobal($3, \"$1\", sizeof($2), $4, (void**)&$1))$N",
-           [v.loc.snippet, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
+           [v.loc.r, rdLoc(v.loc), getModuleDllPath(p.module, v), traverseProc])
     startBlock(targetProc)
   if value.kind != nkEmpty and valueAsRope.len == 0:
     genLineDir(targetProc, vn)
@@ -595,7 +573,8 @@ proc genComputedGoto(p: BProc; n: PNode) =
         return
 
       let val = getOrdValue(it[j])
-      let lit = cIntLiteral(toInt64(val)+id+1)
+      var lit = newRopeAppender()
+      intLiteral(toInt64(val)+id+1, lit)
       lineF(p, cpsStmts, "TMP$#_:$n", [lit])
 
     genStmts(p, it.lastSon)
@@ -755,18 +734,6 @@ proc raiseExit(p: BProc) =
       lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) goto LA$1_;$n",
         [p.nestedTryStmts[^1].label])
 
-proc raiseExitCleanup(p: BProc, destroy: string) =
-  assert p.config.exc == excGoto
-  if nimErrorFlagDisabled notin p.flags:
-    p.flags.incl nimErrorFlagAccessed
-    if p.nestedTryStmts.len == 0:
-      p.flags.incl beforeRetNeeded
-      # easy case, simply goto 'ret':
-      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) {$1; goto BeforeRet_;}$n", [destroy])
-    else:
-      lineCg(p, cpsStmts, "if (NIM_UNLIKELY(*nimErr_)) {$2; goto LA$1_;}$n",
-        [p.nestedTryStmts[^1].label, destroy])
-
 proc finallyActions(p: BProc) =
   if p.config.exc != excGoto and p.nestedTryStmts.len > 0 and p.nestedTryStmts[^1].inExcept:
     # if the current try stmt have a finally block,
@@ -775,7 +742,7 @@ proc finallyActions(p: BProc) =
     if finallyBlock != nil:
       genSimpleBlock(p, finallyBlock[0])
 
-proc raiseInstr(p: BProc; result: var Builder) =
+proc raiseInstr(p: BProc; result: var Rope) =
   if p.config.exc == excGoto:
     let L = p.nestedTryStmts.len
     if L == 0:
@@ -796,14 +763,10 @@ proc genRaiseStmt(p: BProc, t: PNode) =
     var e = rdLoc(a)
     discard getTypeDesc(p.module, t[0].typ)
     var typ = skipTypes(t[0].typ, abstractPtrs)
-    case p.config.exc
-    of excCpp:
+    # XXX For reasons that currently escape me, this is only required by the new
+    # C++ based exception handling:
+    if p.config.exc == excCpp:
       blockLeaveActions(p, howManyTrys = 0, howManyExcepts = p.inExceptBlockLen)
-    of excGoto:
-      blockLeaveActions(p, howManyTrys = 0,
-        howManyExcepts = (if p.nestedTryStmts.len > 0 and p.nestedTryStmts[^1].inExcept: 1 else: 0))
-    else:
-      discard
     genLineDir(p, t)
     if isImportedException(typ, p.config):
       lineF(p, cpsStmts, "throw $1;$n", [e])
@@ -925,7 +888,8 @@ proc genStringCase(p: BProc, t: PNode, stringKind: TTypeKind, d: var TLoc) =
               [rdLoc(a), bitMask])
     for j in 0..high(branches):
       if branches[j] != "":
-        let lit = cIntLiteral(j)
+        var lit = newRopeAppender()
+        intLiteral(j, lit)
         lineF(p, cpsStmts, "case $1: $n$2break;$n",
              [lit, branches[j]])
     lineF(p, cpsStmts, "}$n", []) # else statement:
@@ -963,22 +927,22 @@ proc genCaseRange(p: BProc, branch: PNode) =
   for j in 0..<branch.len-1:
     if branch[j].kind == nkRange:
       if hasSwitchRange in CC[p.config.cCompiler].props:
-        var litA = newBuilder("")
-        var litB = newBuilder("")
+        var litA = newRopeAppender()
+        var litB = newRopeAppender()
         genLiteral(p, branch[j][0], litA)
         genLiteral(p, branch[j][1], litB)
-        lineF(p, cpsStmts, "case $1 ... $2:$n", [extract(litA), extract(litB)])
+        lineF(p, cpsStmts, "case $1 ... $2:$n", [litA, litB])
       else:
         var v = copyNode(branch[j][0])
         while v.intVal <= branch[j][1].intVal:
-          var litA = newBuilder("")
+          var litA = newRopeAppender()
           genLiteral(p, v, litA)
-          lineF(p, cpsStmts, "case $1:$n", [extract(litA)])
+          lineF(p, cpsStmts, "case $1:$n", [litA])
           inc(v.intVal)
     else:
-      var litA = newBuilder("")
+      var litA = newRopeAppender()
       genLiteral(p, branch[j], litA)
-      lineF(p, cpsStmts, "case $1:$n", [extract(litA)])
+      lineF(p, cpsStmts, "case $1:$n", [litA])
 
 proc genOrdinalCase(p: BProc, n: PNode, d: var TLoc) =
   # analyse 'case' statement:
@@ -1074,8 +1038,8 @@ proc genTryCpp(p: BProc, t: PNode, d: var TLoc) =
 
   inc(p.labels, 2)
   let etmp = p.labels
-  #init on locals, fixes #23306
-  lineCg(p, cpsLocals, "std::exception_ptr T$1_;$n", [etmp])
+
+  lineCg(p, cpsStmts, "std::exception_ptr T$1_;$n", [etmp])
 
   let fin = if t[^1].kind == nkFinally: t[^1] else: nil
   p.nestedTryStmts.add((fin, false, 0.Natural))
@@ -1525,12 +1489,7 @@ proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
 
 proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false; result: var Rope) =
   var res = ""
-  let offset =
-    if isAsmStmt: 1 # first son is pragmas
-    else: 0
-
-  for i in offset..<t.len:
-    let it = t[i]
+  for it in t.sons:
     case it.kind
     of nkStrLit..nkTripleStrLit:
       res.add(it.strVal)
@@ -1544,7 +1503,7 @@ proc genAsmOrEmitStmt(p: BProc, t: PNode, isAsmStmt=false; result: var Rope) =
       else:
         discard getTypeDesc(p.module, skipTypes(sym.typ, abstractPtrs))
         fillBackendName(p.module, sym)
-        res.add($sym.loc.snippet)
+        res.add($sym.loc.r)
     of nkTypeOfExpr:
       res.add($getTypeDesc(p.module, it.typ))
     else:
@@ -1574,21 +1533,6 @@ proc genAsmStmt(p: BProc, t: PNode) =
   assert(t.kind == nkAsmStmt)
   genLineDir(p, t)
   var s = newRopeAppender()
-
-  var asmSyntax = ""
-  if (let p = t[0]; p.kind == nkPragma):
-    for i in p:
-      if whichPragma(i) == wAsmSyntax:
-        asmSyntax = i[1].strVal
-
-  if asmSyntax != "" and
-     not (
-      asmSyntax == "gcc" and hasGnuAsm in CC[p.config.cCompiler].props or
-      asmSyntax == "vcc" and hasGnuAsm notin CC[p.config.cCompiler].props):
-    localError(
-      p.config, t.info,
-      "Your compiler does not support the specified inline assembler")
-
   genAsmOrEmitStmt(p, t, isAsmStmt=true, s)
   # see bug #2362, "top level asm statements" seem to be a mis-feature
   # but even if we don't do this, the example in #2362 cannot possibly
@@ -1626,9 +1570,9 @@ proc genPragma(p: BProc, n: PNode) =
     case whichPragma(it)
     of wEmit: genEmit(p, it)
     of wPush:
-      processPushBackendOption(p.config, p.optionsStack, p.options, n, i+1)
+      processPushBackendOption(p.optionsStack, p.options, n, i+1)
     of wPop:
-      processPopBackendOption(p.config, p.optionsStack, p.options)
+      processPopBackendOption(p.optionsStack, p.options)
     else: discard
 
 
@@ -1640,7 +1584,8 @@ proc genDiscriminantCheck(p: BProc, a, tmp: TLoc, objtype: PType,
   if not containsOrIncl(p.module.declaredThings, field.id):
     appcg(p.module, cfsVars, "extern $1",
           [discriminatorTableDecl(p.module, t, field)])
-  let lit = cIntLiteral(toInt64(lengthOrd(p.config, field.typ))+1)
+  var lit = newRopeAppender()
+  intLiteral(toInt64(lengthOrd(p.config, field.typ))+1, lit)
   lineCg(p, cpsStmts,
         "#FieldDiscriminantCheck((NI)(NU)($1), (NI)(NU)($2), $3, $4);$n",
         [rdLoc(a), rdLoc(tmp), discriminatorTableName(p.module, t, field),

compiler/ccgthreadvars.nim

@@ -30,7 +30,7 @@ proc declareThreadVar(m: BModule, s: PSym, isExtern: bool) =
     # allocator for it :-(
     if not containsOrIncl(m.g.nimtvDeclared, s.id):
       m.g.nimtvDeps.add(s.loc.t)
-      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.loc.t), s.loc.snippet])
+      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.loc.t), s.loc.r])
   else:
     if isExtern: m.s[cfsVars].add("extern ")
     elif lfExportLib in s.loc.flags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
@@ -41,15 +41,13 @@ proc declareThreadVar(m: BModule, s: PSym, isExtern: bool) =
         m.s[cfsVars].add("NIM_THREAD_LOCAL ")
       else: m.s[cfsVars].add("NIM_THREADVAR ")
     m.s[cfsVars].add(getTypeDesc(m, s.loc.t))
-    m.s[cfsVars].addf(" $1;$n", [s.loc.snippet])
+    m.s[cfsVars].addf(" $1;$n", [s.loc.r])
 
 proc generateThreadLocalStorage(m: BModule) =
   if m.g.nimtv != "" and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
     for t in items(m.g.nimtvDeps): discard getTypeDesc(m, t)
     finishTypeDescriptions(m)
-    m.s[cfsSeqTypes].addTypedef(name = "NimThreadVars"):
-      m.s[cfsSeqTypes].addSimpleStruct(m, name = "", baseType = ""):
-        m.s[cfsSeqTypes].add(m.g.nimtv)
+    m.s[cfsSeqTypes].addf("typedef struct {$1} NimThreadVars;$n", [m.g.nimtv])
 
 proc generateThreadVarsSize(m: BModule) =
   if m.g.nimtv != "":

compiler/ccgtrav.nim

@@ -34,10 +34,10 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
     if (n[0].kind != nkSym): internalError(c.p.config, n.info, "genTraverseProc")
     var p = c.p
     let disc = n[0].sym
-    if disc.loc.snippet == "": fillObjectFields(c.p.module, typ)
+    if disc.loc.r == "": fillObjectFields(c.p.module, typ)
     if disc.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.r])
     for i in 1..<n.len:
       let branch = n[i]
       assert branch.kind in {nkOfBranch, nkElse}
@@ -51,10 +51,10 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
-    if field.loc.snippet == "": fillObjectFields(c.p.module, typ)
+    if field.loc.r == "": fillObjectFields(c.p.module, typ)
     if field.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    genTraverseProc(c, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
+    genTraverseProc(c, "$1.$2" % [accessor, field.loc.r], field.loc.t)
   else: internalError(c.p.config, n.info, "genTraverseProc()")
 
 proc parentObj(accessor: Rope; m: BModule): Rope {.inline.} =
@@ -71,35 +71,37 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
   case typ.kind
   of tyGenericInst, tyGenericBody, tyTypeDesc, tyAlias, tyDistinct, tyInferred,
      tySink, tyOwned:
-    genTraverseProc(c, accessor, skipModifier(typ))
+    genTraverseProc(c, accessor, lastSon(typ))
   of tyArray:
-    let arraySize = lengthOrd(c.p.config, typ.indexType)
+    let arraySize = lengthOrd(c.p.config, typ[0])
     var i: TLoc = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
     var oldCode = p.s(cpsStmts)
+    freeze oldCode
     linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
-            [i.snippet, arraySize])
-    let oldLen = p.s(cpsStmts).buf.len
-    genTraverseProc(c, ropecg(c.p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
-    if p.s(cpsStmts).buf.len == oldLen:
+            [i.r, arraySize])
+    let oldLen = p.s(cpsStmts).len
+    genTraverseProc(c, ropecg(c.p.module, "$1[$2]", [accessor, i.r]), typ[1])
+    if p.s(cpsStmts).len == oldLen:
       # do not emit dummy long loops for faster debug builds:
       p.s(cpsStmts) = oldCode
     else:
       lineF(p, cpsStmts, "}$n", [])
   of tyObject:
-    var x = typ.baseClass
-    if x != nil: x = x.skipTypes(skipPtrs)
-    genTraverseProc(c, accessor.parentObj(c.p.module), x)
+    for i in 0..<typ.len:
+      var x = typ[i]
+      if x != nil: x = x.skipTypes(skipPtrs)
+      genTraverseProc(c, accessor.parentObj(c.p.module), x)
     if typ.n != nil: genTraverseProc(c, accessor, typ.n, typ)
   of tyTuple:
     let typ = getUniqueType(typ)
-    for i, a in typ.ikids:
-      genTraverseProc(c, ropecg(c.p.module, "$1.Field$2", [accessor, i]), a)
+    for i in 0..<typ.len:
+      genTraverseProc(c, ropecg(c.p.module, "$1.Field$2", [accessor, i]), typ[i])
   of tyRef:
     lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
   of tySequence:
     if optSeqDestructors notin c.p.module.config.globalOptions:
       lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
-    elif containsGarbageCollectedRef(typ.elementType):
+    elif containsGarbageCollectedRef(typ.lastSon):
       # destructor based seqs are themselves not traced but their data is, if
       # they contain a GC'ed type:
       lineCg(p, cpsStmts, "#nimGCvisitSeq((void*)$1, $2);$n", [accessor, c.visitorFrmt])
@@ -116,21 +118,23 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
 proc genTraverseProcSeq(c: TTraversalClosure, accessor: Rope, typ: PType) =
   var p = c.p
   assert typ.kind == tySequence
-  var i = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
+  var i: TLoc = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
   var oldCode = p.s(cpsStmts)
-  var a = TLoc(snippet: accessor)
+  freeze oldCode
+  var a: TLoc = TLoc(r: accessor)
 
   lineF(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
-      [i.snippet, lenExpr(c.p, a)])
-  let oldLen = p.s(cpsStmts).buf.len
-  genTraverseProc(c, "$1$3[$2]" % [accessor, i.snippet, dataField(c.p)], typ.elementType)
-  if p.s(cpsStmts).buf.len == oldLen:
+      [i.r, lenExpr(c.p, a)])
+  let oldLen = p.s(cpsStmts).len
+  genTraverseProc(c, "$1$3[$2]" % [accessor, i.r, dataField(c.p)], typ[0])
+  if p.s(cpsStmts).len == oldLen:
     # do not emit dummy long loops for faster debug builds:
     p.s(cpsStmts) = oldCode
   else:
     lineF(p, cpsStmts, "}$n", [])
 
 proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
+  var c: TTraversalClosure
   var p = newProc(nil, m)
   result = "Marker_" & getTypeName(m, origTyp, sig)
   let
@@ -143,22 +147,21 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
   lineF(p, cpsLocals, "$1 a;$n", [t])
   lineF(p, cpsInit, "a = ($1)p;$n", [t])
 
-  var c = TTraversalClosure(p: p,
-    visitorFrmt: "op" # "#nimGCvisit((void*)$1, op);$n"
-    )
+  c.p = p
+  c.visitorFrmt = "op" # "#nimGCvisit((void*)$1, op);$n"
 
   assert typ.kind != tyTypeDesc
   if typ.kind == tySequence:
     genTraverseProcSeq(c, "a".rope, typ)
   else:
-    if skipTypes(typ.elementType, typedescInst+{tyOwned}).kind == tyArray:
+    if skipTypes(typ[0], typedescInst+{tyOwned}).kind == tyArray:
       # C's arrays are broken beyond repair:
-      genTraverseProc(c, "a".rope, typ.elementType)
+      genTraverseProc(c, "a".rope, typ[0])
     else:
-      genTraverseProc(c, "(*a)".rope, typ.elementType)
+      genTraverseProc(c, "(*a)".rope, typ[0])
 
   let generatedProc = "$1 {$n$2$3$4}\n" %
-        [header, extract(p.s(cpsLocals)), extract(p.s(cpsInit)), extract(p.s(cpsStmts))]
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
   m.s[cfsProcHeaders].addf("$1;\n", [header])
   m.s[cfsProcs].add(generatedProc)
@@ -171,6 +174,7 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
 proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
   discard genTypeInfoV1(m, s.loc.t, info)
 
+  var c: TTraversalClosure
   var p = newProc(nil, m)
   var sLoc = rdLoc(s.loc)
   result = getTempName(m)
@@ -179,15 +183,13 @@ proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
     accessThreadLocalVar(p, s)
     sLoc = "NimTV_->" & sLoc
 
-  var c = TTraversalClosure(p: p,
-    visitorFrmt: "0" # "#nimGCvisit((void*)$1, 0);$n"
-  )
-
+  c.visitorFrmt = "0" # "#nimGCvisit((void*)$1, 0);$n"
+  c.p = p
   let header = "static N_NIMCALL(void, $1)(void)" % [result]
   genTraverseProc(c, sLoc, s.loc.t)
 
   let generatedProc = "$1 {$n$2$3$4}$n" %
-        [header, extract(p.s(cpsLocals)), extract(p.s(cpsInit)), extract(p.s(cpsStmts))]
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
   m.s[cfsProcHeaders].addf("$1;$n", [header])
   m.s[cfsProcs].add(generatedProc)

compiler/ccgutils.nim

@@ -11,9 +11,9 @@
 
 import
   ast, types, msgs, wordrecg,
-  platform, trees, options, cgendata, mangleutils
+  platform, trees, options, cgendata
 
-import std/[hashes, strutils, formatfloat]
+import std/[hashes, strutils]
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -68,6 +68,53 @@ proc makeSingleLineCString*(s: string): string =
     c.toCChar(result)
   result.add('\"')
 
+proc mangle*(name: string): string =
+  result = newStringOfCap(name.len)
+  var start = 0
+  if name[0] in Digits:
+    result.add("X" & name[0])
+    start = 1
+  var requiresUnderscore = false
+  template special(x) =
+    result.add x
+    requiresUnderscore = true
+  for i in start..<name.len:
+    let c = name[i]
+    case c
+    of 'a'..'z', '0'..'9', 'A'..'Z':
+      result.add(c)
+    of '_':
+      # we generate names like 'foo_9' for scope disambiguations and so
+      # disallow this here:
+      if i > 0 and i < name.len-1 and name[i+1] in Digits:
+        discard
+      else:
+        result.add(c)
+    of '$': special "dollar"
+    of '%': special "percent"
+    of '&': special "amp"
+    of '^': special "roof"
+    of '!': special "emark"
+    of '?': special "qmark"
+    of '*': special "star"
+    of '+': special "plus"
+    of '-': special "minus"
+    of '/': special "slash"
+    of '\\': special "backslash"
+    of '=': special "eq"
+    of '<': special "lt"
+    of '>': special "gt"
+    of '~': special "tilde"
+    of ':': special "colon"
+    of '.': special "dot"
+    of '@': special "at"
+    of '|': special "bar"
+    else:
+      result.add("X" & toHex(ord(c), 2))
+      requiresUnderscore = true
+  if requiresUnderscore:
+    result.add "_"
+
 proc mapSetType(conf: ConfigRef; typ: PType): TCTypeKind =
   case int(getSize(conf, typ))
   of 1: result = ctInt8
@@ -79,10 +126,10 @@ proc mapSetType(conf: ConfigRef; typ: PType): TCTypeKind =
 proc ccgIntroducedPtr*(conf: ConfigRef; s: PSym, retType: PType): bool =
   var pt = skipTypes(s.typ, typedescInst)
   assert skResult != s.kind
-
+  
   #note precedence: params override types
   if optByRef in s.options: return true
-  elif sfByCopy in s.flags: return false
+  elif sfByCopy in s.flags: return false 
   elif tfByRef in pt.flags: return true
   elif tfByCopy in pt.flags: return false
   case pt.kind
@@ -90,9 +137,6 @@ proc ccgIntroducedPtr*(conf: ConfigRef; s: PSym, retType: PType): bool =
     if s.typ.sym != nil and sfForward in s.typ.sym.flags:
       # forwarded objects are *always* passed by pointers for consistency!
       result = true
-    elif s.typ.kind == tySink and conf.selectedGC notin {gcArc, gcAtomicArc, gcOrc, gcHooks}:
-      # bug #23354:
-      result = false
     elif (optByRef in s.options) or (getSize(conf, pt) > conf.target.floatSize * 3):
       result = true           # requested anyway
     elif (tfFinal in pt.flags) and (pt[0] == nil):
@@ -109,62 +153,3 @@ proc ccgIntroducedPtr*(conf: ConfigRef; s: PSym, retType: PType): bool =
     result = not (pt.kind in {tyVar, tyArray, tyOpenArray, tyVarargs, tyRef, tyPtr, tyPointer} or
       pt.kind == tySet and mapSetType(conf, pt) == ctArray)
 
-proc encodeName*(name: string): string =
-  result = mangle(name)
-  result = $result.len & result
-
-proc makeUnique(m: BModule; s: PSym, name: string = ""): string =
-  result = if name == "": s.name.s else: name
-  result.add "__"
-  result.add m.g.graph.ifaces[s.itemId.module].uniqueName
-  result.add "_u"
-  result.add $s.itemId.item
-
-proc encodeSym*(m: BModule; s: PSym; makeUnique: bool = false): string =
-  #Module::Type
-  var name = s.name.s
-  if makeUnique:
-    name = makeUnique(m, s, name)
-  "N" & encodeName(s.skipGenericOwner.name.s) & encodeName(name) & "E"
-
-proc encodeType*(m: BModule; t: PType): string =
-  result = ""
-  var kindName = ($t.kind)[2..^1]
-  kindName[0] = toLower($kindName[0])[0]
-  case t.kind
-  of tyObject, tyEnum, tyDistinct, tyUserTypeClass, tyGenericParam:
-    result = encodeSym(m, t.sym)
-  of tyGenericInst, tyUserTypeClassInst, tyGenericBody:
-    result = encodeName(t[0].sym.name.s)
-    result.add "I"
-    for i in 1..<t.len - 1:
-      result.add encodeType(m, t[i])
-    result.add "E"
-  of tySequence, tyOpenArray, tyArray, tyVarargs, tyTuple, tyProc, tySet, tyTypeDesc,
-    tyPtr, tyRef, tyVar, tyLent, tySink, tyStatic, tyUncheckedArray, tyOr, tyAnd, tyBuiltInTypeClass:
-    result =
-      case t.kind:
-      of tySequence: encodeName("seq")
-      else: encodeName(kindName)
-    result.add "I"
-    for i in 0..<t.len:
-      let s = t[i]
-      if s.isNil: continue
-      result.add encodeType(m, s)
-    result.add "E"
-  of tyRange:
-    var val = "range_"
-    if t.n[0].typ.kind in {tyFloat..tyFloat128}:
-      val.addFloat t.n[0].floatVal
-      val.add "_"
-      val.addFloat t.n[1].floatVal
-    else:
-      val.add $t.n[0].intVal & "_" & $t.n[1].intVal
-    result = encodeName(val)
-  of tyString..tyUInt64, tyPointer, tyBool, tyChar, tyVoid, tyAnything, tyNil, tyEmpty:
-    result = encodeName(kindName)
-  of tyAlias, tyInferred, tyOwned:
-    result = encodeType(m, t.elementType)
-  else:
-    assert false, "encodeType " & $t.kind
-

compiler/cgendata.nim

@@ -11,7 +11,7 @@
 
 import
   ast, ropes, options,
-  lineinfos, pathutils, modulegraphs, cbuilderbase
+  ndi, lineinfos, pathutils, modulegraphs
 
 import std/[intsets, tables, sets]
 
@@ -43,12 +43,12 @@ type
     ctUInt, ctUInt8, ctUInt16, ctUInt32, ctUInt64,
     ctArray, ctPtrToArray, ctStruct, ctPtr, ctNimStr, ctNimSeq, ctProc,
     ctCString
-  TCFileSections* = array[TCFileSection, Builder] # represents a generated C file
+  TCFileSections* = array[TCFileSection, Rope] # represents a generated C file
   TCProcSection* = enum       # the sections a generated C proc consists of
     cpsLocals,                # section of local variables for C proc
     cpsInit,                  # section for init of variables for C proc
     cpsStmts                  # section of local statements for C proc
-  TCProcSections* = array[TCProcSection, Builder] # represents a generated C proc
+  TCProcSections* = array[TCProcSection, Rope] # represents a generated C proc
   BModule* = ref TCGen
   BProc* = ref TCProc
   TBlock* = object
@@ -88,7 +88,7 @@ type
     options*: TOptions        # options that should be used for code
                               # generation; this is the same as prc.options
                               # unless prc == nil
-    optionsStack*: seq[(TOptions, TNoteKinds)]
+    optionsStack*: seq[TOptions]
     module*: BModule          # used to prevent excessive parameter passing
     withinLoop*: int          # > 0 if we are within a loop
     splitDecls*: int          # > 0 if we are in some context for C++ that
@@ -137,7 +137,6 @@ type
                             # unconditionally...
                             # nimtvDeps is VERY hard to cache because it's
                             # not a list of IDs nor can it be made to be one.
-    mangledPrcs*: HashSet[string]
 
   TCGen = object of PPassContext # represents a C source file
     s*: TCFileSections        # sections of the C file
@@ -151,7 +150,7 @@ type
     typeABICache*: HashSet[SigHash] # cache for ABI checks; reusing typeCache
                               # would be ideal but for some reason enums
                               # don't seem to get cached so it'd generate
-                              # 1 ABI check per occurrence in code
+                              # 1 ABI check per occurence in code
     forwTypeCache*: TypeCache # cache for forward declarations of types
     declaredThings*: IntSet   # things we have declared in this .c file
     declaredProtos*: IntSet   # prototypes we have declared in this .c file
@@ -161,7 +160,7 @@ type
     typeInfoMarkerV2*: TypeCache
     initProc*: BProc          # code for init procedure
     preInitProc*: BProc       # code executed before the init proc
-    hcrCreateTypeInfosProc*: Builder # type info globals are in here when HCR=on
+    hcrCreateTypeInfosProc*: Rope # type info globals are in here when HCR=on
     inHcrInitGuard*: bool     # We are currently within a HCR reloading guard.
     typeStack*: TTypeSeq      # used for type generation
     dataCache*: TNodeTable
@@ -172,6 +171,7 @@ type
                                              # OpenGL wrapper
     sigConflicts*: CountTable[SigHash]
     g*: BModuleList
+    ndi*: NdiFile
 
 template config*(m: BModule): ConfigRef = m.g.config
 template config*(p: BProc): ConfigRef = p.module.g.config
@@ -181,18 +181,18 @@ proc includeHeader*(this: BModule; header: string) =
   if not this.headerFiles.contains header:
     this.headerFiles.add header
 
-proc s*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc s*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # section in the current block
   result = p.blocks[^1].sections[s]
 
-proc procSec*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc procSec*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # top level proc sections
   result = p.blocks[0].sections[s]
 
 proc initBlock*(): TBlock =
   result = TBlock()
   for i in low(result.sections)..high(result.sections):
-    result.sections[i] = newBuilder("")
+    result.sections[i] = newRopeAppender()
 
 proc newProc*(prc: PSym, module: BModule): BProc =
   result = BProc(

compiler/cgmeth.nim

@@ -55,7 +55,7 @@ proc methodCall*(n: PNode; conf: ConfigRef): PNode =
   # replace ordinary method by dispatcher method:
   let disp = getDispatcher(result[0].sym)
   if disp != nil:
-    result[0].typ() = disp.typ
+    result[0].typ = disp.typ
     result[0].sym = disp
     # change the arguments to up/downcasts to fit the dispatcher's parameters:
     for i in 1..<result.len:
@@ -69,23 +69,21 @@ type
 proc sameMethodBucket(a, b: PSym; multiMethods: bool): MethodResult =
   result = No
   if a.name.id != b.name.id: return
-  if a.typ.signatureLen != b.typ.signatureLen:
+  if a.typ.len != b.typ.len:
     return
 
-  var i = 0
-  for x, y in paramTypePairs(a.typ, b.typ):
-    inc i
-    var aa = x
-    var bb = y
+  for i in 1..<a.typ.len:
+    var aa = a.typ[i]
+    var bb = b.typ[i]
     while true:
       aa = skipTypes(aa, {tyGenericInst, tyAlias})
       bb = skipTypes(bb, {tyGenericInst, tyAlias})
       if aa.kind == bb.kind and aa.kind in {tyVar, tyPtr, tyRef, tyLent, tySink}:
-        aa = aa.elementType
-        bb = bb.elementType
+        aa = aa.lastSon
+        bb = bb.lastSon
       else:
         break
-    if sameType(x, y):
+    if sameType(a.typ[i], b.typ[i]):
       if aa.kind == tyObject and result != Invalid:
         result = Yes
     elif aa.kind == tyObject and bb.kind == tyObject and (i == 1 or multiMethods):
@@ -104,10 +102,10 @@ proc sameMethodBucket(a, b: PSym; multiMethods: bool): MethodResult =
   if result == Yes:
     # check for return type:
     # ignore flags of return types; # bug #22673
-    if not sameTypeOrNil(a.typ.returnType, b.typ.returnType, {IgnoreFlags}):
-      if b.typ.returnType != nil and b.typ.returnType.kind == tyUntyped:
+    if not sameTypeOrNil(a.typ[0], b.typ[0], {IgnoreFlags}):
+      if b.typ[0] != nil and b.typ[0].kind == tyUntyped:
         # infer 'auto' from the base to make it consistent:
-        b.typ.setReturnType a.typ.returnType
+        b.typ[0] = a.typ[0]
       else:
         return No
 
@@ -133,8 +131,8 @@ proc createDispatcher(s: PSym; g: ModuleGraph; idgen: IdGenerator): PSym =
   if disp.typ.callConv == ccInline: disp.typ.callConv = ccNimCall
   disp.ast = copyTree(s.ast)
   disp.ast[bodyPos] = newNodeI(nkEmpty, s.info)
-  disp.loc.snippet = ""
-  if s.typ.returnType != nil:
+  disp.loc.r = ""
+  if s.typ[0] != nil:
     if disp.ast.len > resultPos:
       disp.ast[resultPos].sym = copySym(s.ast[resultPos].sym, idgen)
     else:
@@ -159,14 +157,9 @@ proc fixupDispatcher(meth, disp: PSym; conf: ConfigRef) =
 
 proc methodDef*(g: ModuleGraph; idgen: IdGenerator; s: PSym) =
   var witness: PSym = nil
-  if s.typ.firstParamType.owner.getModule != s.getModule and vtables in g.config.features and not
-      g.config.isDefined("nimInternalNonVtablesTesting"):
+  if s.typ[1].owner.getModule != s.getModule and vtables in g.config.features and not g.config.isDefined("nimInternalNonVtablesTesting"):
     localError(g.config, s.info, errGenerated, "method `" & s.name.s &
-          "` can be defined only in the same module with its type (" & s.typ.firstParamType.typeToString() & ")")
-  if sfImportc in s.flags:
-    localError(g.config, s.info, errGenerated, "method `" & s.name.s &
-          "` is not allowed to have 'importc' pragmas")
-
+          "` can be defined only in the same module with its type (" & s.typ[1].typeToString() & ")")
   for i in 0..<g.methods.len:
     let disp = g.methods[i].dispatcher
     case sameMethodBucket(disp, s, multimethods = optMultiMethods in g.config.globalOptions)
@@ -186,10 +179,10 @@ proc methodDef*(g: ModuleGraph; idgen: IdGenerator; s: PSym) =
       if witness.isNil: witness = g.methods[i].methods[0]
   # create a new dispatcher:
   # stores the id and the position
-  if s.typ.firstParamType.skipTypes(skipPtrs).itemId notin g.bucketTable:
-    g.bucketTable[s.typ.firstParamType.skipTypes(skipPtrs).itemId] = 1
+  if s.typ[1].skipTypes(skipPtrs).itemId notin g.bucketTable:
+    g.bucketTable[s.typ[1].skipTypes(skipPtrs).itemId] = 1
   else:
-    g.bucketTable.inc(s.typ.firstParamType.skipTypes(skipPtrs).itemId)
+    g.bucketTable.inc(s.typ[1].skipTypes(skipPtrs).itemId)
   g.methods.add((methods: @[s], dispatcher: createDispatcher(s, g, idgen)))
   #echo "adding ", s.info
   if witness != nil:
@@ -210,7 +203,7 @@ proc relevantCol*(methods: seq[PSym], col: int): bool =
 
 proc cmpSignatures(a, b: PSym, relevantCols: IntSet): int =
   result = 0
-  for col in FirstParamAt..<a.typ.signatureLen:
+  for col in 1..<a.typ.len:
     if contains(relevantCols, col):
       var aa = skipTypes(a.typ[col], skipPtrs)
       var bb = skipTypes(b.typ[col], skipPtrs)
@@ -240,13 +233,13 @@ proc sortBucket*(a: var seq[PSym], relevantCols: IntSet) =
 proc genIfDispatcher*(g: ModuleGraph; methods: seq[PSym], relevantCols: IntSet; idgen: IdGenerator): PSym =
   var base = methods[0].ast[dispatcherPos].sym
   result = base
-  var paramLen = base.typ.signatureLen
+  var paramLen = base.typ.len
   var nilchecks = newNodeI(nkStmtList, base.info)
   var disp = newNodeI(nkIfStmt, base.info)
   var ands = getSysMagic(g, unknownLineInfo, "and", mAnd)
   var iss = getSysMagic(g, unknownLineInfo, "of", mOf)
   let boolType = getSysType(g, unknownLineInfo, tyBool)
-  for col in FirstParamAt..<paramLen:
+  for col in 1..<paramLen:
     if contains(relevantCols, col):
       let param = base.typ.n[col].sym
       if param.typ.skipTypes(abstractInst).kind in {tyRef, tyPtr}:
@@ -255,7 +248,7 @@ proc genIfDispatcher*(g: ModuleGraph; methods: seq[PSym], relevantCols: IntSet;
   for meth in 0..high(methods):
     var curr = methods[meth]      # generate condition:
     var cond: PNode = nil
-    for col in FirstParamAt..<paramLen:
+    for col in 1..<paramLen:
       if contains(relevantCols, col):
         var isn = newNodeIT(nkCall, base.info, boolType)
         isn.add newSymNode(iss)
@@ -270,7 +263,7 @@ proc genIfDispatcher*(g: ModuleGraph; methods: seq[PSym], relevantCols: IntSet;
           cond = a
         else:
           cond = isn
-    let retTyp = base.typ.returnType
+    let retTyp = base.typ[0]
     let call = newNodeIT(nkCall, base.info, retTyp)
     call.add newSymNode(curr)
     for col in 1..<paramLen:
@@ -299,7 +292,7 @@ proc genIfDispatcher*(g: ModuleGraph; methods: seq[PSym], relevantCols: IntSet;
 proc generateIfMethodDispatchers*(g: ModuleGraph, idgen: IdGenerator) =
   for bucket in 0..<g.methods.len:
     var relevantCols = initIntSet()
-    for col in FirstParamAt..<g.methods[bucket].methods[0].typ.signatureLen:
+    for col in 1..<g.methods[bucket].methods[0].typ.len:
       if relevantCol(g.methods[bucket].methods, col): incl(relevantCols, col)
       if optMultiMethods notin g.config.globalOptions:
         # if multi-methods are not enabled, we are interested only in the first field

compiler/closureiters.nim

@@ -18,8 +18,7 @@
 #    dec a
 #
 # Should be transformed to:
-#  case :state
-#  of 0:
+#  STATE0:
 #    if a > 0:
 #      echo "hi"
 #      :state = 1 # Next state
@@ -27,14 +26,19 @@
 #    else:
 #      :state = 2 # Next state
 #      break :stateLoop # Proceed to the next state
-#  of 1:
+#  STATE1:
 #    dec a
 #    :state = 0 # Next state
 #    break :stateLoop # Proceed to the next state
-#  of 2:
+#  STATE2:
 #    :state = -1 # End of execution
-#  else:
-#    return
+
+# The transformation should play well with lambdalifting, however depending
+# on situation, it can be called either before or after lambdalifting
+# transformation. As such we behave slightly differently, when accessing
+# iterator state, or using temp variables. If lambdalifting did not happen,
+# we just create local variables, so that they will be lifted further on.
+# Otherwise, we utilize existing env, created by lambdalifting.
 
 # Lambdalifting treats :state variable specially, it should always end up
 # as the first field in env. Currently C codegen depends on this behavior.
@@ -100,13 +104,12 @@
 # Is transformed to (yields are left in place for example simplicity,
 #    in reality the code is subdivided even more, as described above):
 #
-# case :state
-# of 0: # Try
+# STATE0: # Try
 #   yield 0
 #   raise ...
 #   :state = 2 # What would happen should we not raise
 #   break :stateLoop
-# of 1: # Except
+# STATE1: # Except
 #   yield 1
 #   :tmpResult = 3           # Return
 #   :unrollFinally = true # Return
@@ -114,7 +117,7 @@
 #   break :stateLoop
 #   :state = 2 # What would happen should we not return
 #   break :stateLoop
-# of 2: # Finally
+# STATE2: # Finally
 #   yield 2
 #   if :unrollFinally: # This node is created by `newEndFinallyNode`
 #     if :curExc.isNil:
@@ -127,8 +130,6 @@
 #       raise
 #   state = -1 # Goto next state. In this case we just exit
 #   break :stateLoop
-# else:
-#   return
 
 import
   ast, msgs, idents,
@@ -144,11 +145,12 @@ type
   Ctx = object
     g: ModuleGraph
     fn: PSym
+    stateVarSym: PSym # :state variable. nil if env already introduced by lambdalifting
     tmpResultSym: PSym # Used when we return, but finally has to interfere
     unrollFinallySym: PSym # Indicates that we're unrolling finally states (either exception happened or premature return)
     curExcSym: PSym # Current exception
 
-    states: seq[tuple[label: int, body: PNode]] # The resulting states.
+    states: seq[PNode] # The resulting states. Every state is an nkState node.
     blockLevel: int # Temp used to transform break and continue stmts
     stateLoopLabel: PSym # Label to break on, when jumping between states.
     exitStateIdx: int # index of the last state
@@ -160,18 +162,17 @@ type
     nearestFinally: int # Index of the nearest finally block. For try/except it
                     # is their finally. For finally it is parent finally. Otherwise -1
     idgen: IdGenerator
-    varStates: Table[ItemId, int] # Used to detect if local variable belongs to multiple states
 
 const
   nkSkip = {nkEmpty..nkNilLit, nkTemplateDef, nkTypeSection, nkStaticStmt,
             nkCommentStmt, nkMixinStmt, nkBindStmt} + procDefs
-  emptyStateLabel = -1
-  localNotSeen = -1
-  localRequiresLifting = -2
 
 proc newStateAccess(ctx: var Ctx): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
-      getStateField(ctx.g, ctx.fn), ctx.fn.info)
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)),
+        getStateField(ctx.g, ctx.fn), ctx.fn.info)
+  else:
+    result = newSymNode(ctx.stateVarSym)
 
 proc newStateAssgn(ctx: var Ctx, toValue: PNode): PNode =
   # Creates state assignment:
@@ -186,22 +187,28 @@ proc newStateAssgn(ctx: var Ctx, stateNo: int = -2): PNode =
 proc newEnvVar(ctx: var Ctx, name: string, typ: PType): PSym =
   result = newSym(skVar, getIdent(ctx.g.cache, name), ctx.idgen, ctx.fn, ctx.fn.info)
   result.typ = typ
-  result.flags.incl sfNoInit
-  assert(not typ.isNil, "Env var needs a type")
+  assert(not typ.isNil)
 
-  let envParam = getEnvParam(ctx.fn)
-  # let obj = envParam.typ.lastSon
-  result = addUniqueField(envParam.typ.elementType, result, ctx.g.cache, ctx.idgen)
+  if not ctx.stateVarSym.isNil:
+    # We haven't gone through labmda lifting yet, so just create a local var,
+    # it will be lifted later
+    if ctx.tempVars.isNil:
+      ctx.tempVars = newNodeI(nkVarSection, ctx.fn.info)
+      addVar(ctx.tempVars, newSymNode(result))
+  else:
+    let envParam = getEnvParam(ctx.fn)
+    # let obj = envParam.typ.lastSon
+    result = addUniqueField(envParam.typ.lastSon, result, ctx.g.cache, ctx.idgen)
 
 proc newEnvVarAccess(ctx: Ctx, s: PSym): PNode =
-  result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
-
-proc newTempVarAccess(ctx: Ctx, s: PSym): PNode =
-  result = newSymNode(s, ctx.fn.info)
+  if ctx.stateVarSym.isNil:
+    result = rawIndirectAccess(newSymNode(getEnvParam(ctx.fn)), s, ctx.fn.info)
+  else:
+    result = newSymNode(s)
 
 proc newTmpResultAccess(ctx: var Ctx): PNode =
   if ctx.tmpResultSym.isNil:
-    ctx.tmpResultSym = ctx.newEnvVar(":tmpResult", ctx.fn.typ.returnType)
+    ctx.tmpResultSym = ctx.newEnvVar(":tmpResult", ctx.fn.typ[0])
   ctx.newEnvVarAccess(ctx.tmpResultSym)
 
 proc newUnrollFinallyAccess(ctx: var Ctx, info: TLineInfo): PNode =
@@ -221,7 +228,10 @@ proc newState(ctx: var Ctx, n, gotoOut: PNode): int =
 
   result = ctx.states.len
   let resLit = ctx.g.newIntLit(n.info, result)
-  ctx.states.add((result, n))
+  let s = newNodeI(nkState, n.info)
+  s.add(resLit)
+  s.add(n)
+  ctx.states.add(s)
   ctx.exceptionTable.add(ctx.curExcHandlingState)
 
   if not gotoOut.isNil:
@@ -240,18 +250,9 @@ proc addGotoOut(n: PNode, gotoOut: PNode): PNode =
   if result.len == 0 or result[^1].kind != nkGotoState:
     result.add(gotoOut)
 
-proc newTempVarDef(ctx: Ctx, s: PSym, initialValue: PNode): PNode =
-  var v = initialValue
-  if v == nil:
-    v = ctx.g.emptyNode
-  newTree(nkVarSection, newTree(nkIdentDefs, newSymNode(s), ctx.g.emptyNode, v))
-
-proc newTempVar(ctx: var Ctx, typ: PType, parent: PNode, initialValue: PNode = nil): PSym =
-  result = newSym(skVar, getIdent(ctx.g.cache, ":tmpSlLower" & $ctx.tempVarId), ctx.idgen, ctx.fn, ctx.fn.info)
+proc newTempVar(ctx: var Ctx, typ: PType): PSym =
+  result = ctx.newEnvVar(":tmpSlLower" & $ctx.tempVarId, typ)
   inc ctx.tempVarId
-  result.typ = typ
-  assert(not typ.isNil, "Temp var needs a type")
-  parent.add(ctx.newTempVarDef(result, initialValue))
 
 proc hasYields(n: PNode): bool =
   # TODO: This is very inefficient. It traverses the node, looking for nkYieldStmt.
@@ -262,8 +263,8 @@ proc hasYields(n: PNode): bool =
     result = false
   else:
     result = false
-    for i in ord(n.kind == nkCast)..<n.len:
-      if n[i].hasYields:
+    for c in n:
+      if c.hasYields:
         result = true
         break
 
@@ -311,12 +312,12 @@ proc newNullifyCurExc(ctx: var Ctx, info: TLineInfo): PNode =
   let curExc = ctx.newCurExcAccess()
   curExc.info = info
   let nilnode = newNode(nkNilLit)
-  nilnode.typ() = curExc.typ
+  nilnode.typ = curExc.typ
   result = newTree(nkAsgn, curExc, nilnode)
 
 proc newOr(g: ModuleGraph, a, b: PNode): PNode {.inline.} =
   result = newTree(nkCall, newSymNode(g.getSysMagic(a.info, "or", mOr)), a, b)
-  result.typ() = g.getSysType(a.info, tyBool)
+  result.typ = g.getSysType(a.info, tyBool)
   result.info = a.info
 
 proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
@@ -334,7 +335,7 @@ proc collectExceptState(ctx: var Ctx, n: PNode): PNode {.inline.} =
             newSymNode(g.getSysMagic(c.info, "of", mOf)),
             g.callCodegenProc("getCurrentException"),
             c[i])
-          nextCond.typ() = ctx.g.getSysType(c.info, tyBool)
+          nextCond.typ = ctx.g.getSysType(c.info, tyBool)
           nextCond.info = c.info
 
           if cond.isNil:
@@ -412,7 +413,7 @@ proc hasYieldsInExpressions(n: PNode): bool =
 
 proc exprToStmtList(n: PNode): tuple[s, res: PNode] =
   assert(n.kind == nkStmtListExpr)
-  result = (newNodeI(nkStmtList, n.info), nil)
+  result.s = newNodeI(nkStmtList, n.info)
   result.s.sons = @[]
 
   var n = n
@@ -423,20 +424,21 @@ proc exprToStmtList(n: PNode): tuple[s, res: PNode] =
 
   result.res = n
 
-proc newTempVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
+
+proc newEnvVarAsgn(ctx: Ctx, s: PSym, v: PNode): PNode =
   if isEmptyType(v.typ):
     result = v
   else:
-    result = newTree(nkFastAsgn, ctx.newTempVarAccess(s), v)
+    result = newTree(nkFastAsgn, ctx.newEnvVarAccess(s), v)
     result.info = v.info
 
 proc addExprAssgn(ctx: Ctx, output, input: PNode, sym: PSym) =
   if input.kind == nkStmtListExpr:
     let (st, res) = exprToStmtList(input)
     output.add(st)
-    output.add(ctx.newTempVarAsgn(sym, res))
+    output.add(ctx.newEnvVarAsgn(sym, res))
   else:
-    output.add(ctx.newTempVarAsgn(sym, input))
+    output.add(ctx.newEnvVarAsgn(sym, input))
 
 proc convertExprBodyToAsgn(ctx: Ctx, exprBody: PNode, res: PSym): PNode =
   result = newNodeI(nkStmtList, exprBody.info)
@@ -444,17 +446,7 @@ proc convertExprBodyToAsgn(ctx: Ctx, exprBody: PNode, res: PSym): PNode =
 
 proc newNotCall(g: ModuleGraph; e: PNode): PNode =
   result = newTree(nkCall, newSymNode(g.getSysMagic(e.info, "not", mNot), e.info), e)
-  result.typ() = g.getSysType(e.info, tyBool)
-
-proc boolLit(g: ModuleGraph; info: TLineInfo; value: bool): PNode =
-  result = newIntLit(g, info, ord value)
-  result.typ() = getSysType(g, info, tyBool)
-
-proc captureVar(c: var Ctx, s: PSym) =
-  if c.varStates.getOrDefault(s.itemId) != localRequiresLifting:
-    c.varStates[s.itemId] = localRequiresLifting # Mark this variable for lifting
-    let e = getEnvParam(c.fn)
-    discard addField(e.typ.elementType, s, c.g.cache, c.idgen)
+  result.typ = g.getSysType(e.info, tyBool)
 
 proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
   result = n
@@ -486,7 +478,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       result = newNodeI(nkStmtListExpr, n.info)
       if n.typ.isNil: internalError(ctx.g.config, "lowerStmtListExprs: constr typ.isNil")
-      result.typ() = n.typ
+      result.typ = n.typ
 
       for i in 0..<n.len:
         case n[i].kind
@@ -512,9 +504,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       var tmp: PSym = nil
       let isExpr = not isEmptyType(n.typ)
       if isExpr:
+        tmp = ctx.newTempVar(n.typ)
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
-        tmp = ctx.newTempVar(n.typ, result)
+        result.typ = n.typ
       else:
         result = newNodeI(nkStmtList, n.info)
 
@@ -565,7 +557,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         else:
           internalError(ctx.g.config, "lowerStmtListExpr(nkIf): " & $branch.kind)
 
-      if isExpr: result.add(ctx.newTempVarAccess(tmp))
+      if isExpr: result.add(ctx.newEnvVarAccess(tmp))
 
   of nkTryStmt, nkHiddenTryStmt:
     var ns = false
@@ -578,8 +570,8 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
-        let tmp = ctx.newTempVar(n.typ, result)
+        result.typ = n.typ
+        let tmp = ctx.newTempVar(n.typ)
 
         n[0] = ctx.convertExprBodyToAsgn(n[0], tmp)
         for i in 1..<n.len:
@@ -595,7 +587,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkTryStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
 
   of nkCaseStmt:
     var ns = false
@@ -608,9 +600,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
       let isExpr = not isEmptyType(n.typ)
 
       if isExpr:
+        let tmp = ctx.newTempVar(n.typ)
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
-        let tmp = ctx.newTempVar(n.typ, result)
+        result.typ = n.typ
 
         if n[0].kind == nkStmtListExpr:
           let (st, ex) = exprToStmtList(n[0])
@@ -627,7 +619,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           else:
             internalError(ctx.g.config, "lowerStmtListExpr(nkCaseStmt): " & $branch.kind)
         result.add(n)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
       elif n[0].kind == nkStmtListExpr:
         result = newNodeI(nkStmtList, n.info)
         let (st, ex) = exprToStmtList(n[0])
@@ -646,7 +638,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
 
       if isExpr:
         result = newNodeI(nkStmtListExpr, n.info)
-        result.typ() = n.typ
+        result.typ = n.typ
       else:
         result = newNodeI(nkStmtList, n.info)
 
@@ -657,10 +649,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           result.add(st)
           cond = ex
 
-        let tmp = ctx.newTempVar(cond.typ, result, cond)
-        # result.add(ctx.newTempVarAsgn(tmp, cond))
+        let tmp = ctx.newTempVar(cond.typ)
+        result.add(ctx.newEnvVarAsgn(tmp, cond))
 
-        var check = ctx.newTempVarAccess(tmp)
+        var check = ctx.newEnvVarAccess(tmp)
         if n[0].sym.magic == mOr:
           check = ctx.g.newNotCall(check)
 
@@ -670,12 +662,12 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
           let (st, ex) = exprToStmtList(cond)
           ifBody.add(st)
           cond = ex
-        ifBody.add(ctx.newTempVarAsgn(tmp, cond))
+        ifBody.add(ctx.newEnvVarAsgn(tmp, cond))
 
         let ifBranch = newTree(nkElifBranch, check, ifBody)
         let ifNode = newTree(nkIfStmt, ifBranch)
         result.add(ifNode)
-        result.add(ctx.newTempVarAccess(tmp))
+        result.add(ctx.newEnvVarAccess(tmp))
       else:
         for i in 0..<n.len:
           if n[i].kind == nkStmtListExpr:
@@ -684,9 +676,9 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
             n[i] = ex
 
           if n[i].kind in nkCallKinds: # XXX: This should better be some sort of side effect tracking
-            let tmp = ctx.newTempVar(n[i].typ, result, n[i])
-            # result.add(ctx.newTempVarAsgn(tmp, n[i]))
-            n[i] = ctx.newTempVarAccess(tmp)
+            let tmp = ctx.newTempVar(n[i].typ)
+            result.add(ctx.newEnvVarAsgn(tmp, n[i]))
+            n[i] = ctx.newEnvVarAccess(tmp)
 
         result.add(n)
 
@@ -702,12 +694,6 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         let (st, ex) = exprToStmtList(c[^1])
         result.add(st)
         c[^1] = ex
-      for i in 0 .. c.len - 3:
-        if c[i].kind == nkSym:
-          let s = c[i].sym
-          if sfForceLift in s.flags:
-            ctx.captureVar(s)
-
       result.add(varSect)
 
   of nkDiscardStmt, nkReturnStmt, nkRaiseStmt:
@@ -732,7 +718,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[^1])
       result.add(st)
       n[^1] = ex
@@ -793,7 +779,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
         let check = newTree(nkIfStmt, branch)
         let newBody = newTree(nkStmtList, st, check, n[1])
 
-        n[0] = ctx.g.boolLit(n[0].info, true)
+        n[0] = newSymNode(ctx.g.getSysSym(n[0].info, "true"))
         n[1] = newBody
 
   of nkDotExpr, nkCheckedFieldExpr:
@@ -802,7 +788,7 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[0])
       result.add(st)
       n[0] = ex
@@ -814,10 +800,10 @@ proc lowerStmtListExprs(ctx: var Ctx, n: PNode, needsSplit: var bool): PNode =
     if ns:
       needsSplit = true
       result = newNodeI(nkStmtListExpr, n.info)
-      result.typ() = n.typ
+      result.typ = n.typ
       let (st, ex) = exprToStmtList(n[1])
       n.transitionSonsKind(nkBlockStmt)
-      n.typ() = nil
+      n.typ = nil
       n[1] = st
       result.add(n)
       result.add(ex)
@@ -838,14 +824,14 @@ proc newEndFinallyNode(ctx: var Ctx, info: TLineInfo): PNode =
   #         raise
   let curExc = ctx.newCurExcAccess()
   let nilnode = newNode(nkNilLit)
-  nilnode.typ() = curExc.typ
+  nilnode.typ = curExc.typ
   let cmp = newTree(nkCall, newSymNode(ctx.g.getSysMagic(info, "==", mEqRef), info), curExc, nilnode)
-  cmp.typ() = ctx.g.getSysType(info, tyBool)
+  cmp.typ = ctx.g.getSysType(info, tyBool)
 
   let retStmt =
     if ctx.nearestFinally == 0:
       # last finally, we can return
-      let retValue = if ctx.fn.typ.returnType.isNil:
+      let retValue = if ctx.fn.typ[0].isNil:
                    ctx.g.emptyNode
                  else:
                    newTree(nkFastAsgn,
@@ -1147,10 +1133,10 @@ proc skipEmptyStates(ctx: Ctx, stateIdx: int): int =
     let label = stateIdx
     if label == ctx.exitStateIdx: break
     var newLabel = label
-    if label == emptyStateLabel:
+    if label == -1:
       newLabel = ctx.exitStateIdx
     else:
-      let fs = skipStmtList(ctx, ctx.states[label].body)
+      let fs = skipStmtList(ctx, ctx.states[label][1])
       if fs.kind == nkGotoState:
         newLabel = fs[0].intVal.int
     if label == newLabel: break
@@ -1159,7 +1145,7 @@ proc skipEmptyStates(ctx: Ctx, stateIdx: int): int =
     if maxJumps == 0:
       assert(false, "Internal error")
 
-  result = ctx.states[stateIdx].label
+  result = ctx.states[stateIdx][0].intVal.int
 
 proc skipThroughEmptyStates(ctx: var Ctx, n: PNode): PNode=
   result = n
@@ -1185,11 +1171,11 @@ proc newArrayType(g: ModuleGraph; n: int, t: PType; idgen: IdGenerator; owner: P
 
 proc createExceptionTable(ctx: var Ctx): PNode {.inline.} =
   result = newNodeI(nkBracket, ctx.fn.info)
-  result.typ() = ctx.g.newArrayType(ctx.exceptionTable.len, ctx.g.getSysType(ctx.fn.info, tyInt16), ctx.idgen, ctx.fn)
+  result.typ = ctx.g.newArrayType(ctx.exceptionTable.len, ctx.g.getSysType(ctx.fn.info, tyInt16), ctx.idgen, ctx.fn)
 
   for i in ctx.exceptionTable:
     let elem = newIntNode(nkIntLit, i)
-    elem.typ() = ctx.g.getSysType(ctx.fn.info, tyInt16)
+    elem.typ = ctx.g.getSysType(ctx.fn.info, tyInt16)
     result.add(elem)
 
 proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
@@ -1212,7 +1198,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
     let getNextState = newTree(nkBracketExpr,
       ctx.createExceptionTable(),
       ctx.newStateAccess())
-    getNextState.typ() = intTyp
+    getNextState.typ = intTyp
 
     # :state = exceptionTable[:state]
     result.add(ctx.newStateAssgn(getNextState))
@@ -1223,7 +1209,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "==", mEqI).newSymNode(),
       ctx.newStateAccess(),
       newIntTypeNode(0, intTyp))
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let raiseStmt = newTree(nkRaiseStmt, ctx.g.emptyNode)
     let ifBranch = newTree(nkElifBranch, cond, raiseStmt)
@@ -1236,7 +1222,7 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
       newIntTypeNode(0, intTyp),
       ctx.newStateAccess())
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let asgn = newTree(nkAsgn, ctx.newUnrollFinallyAccess(info), cond)
     result.add(asgn)
@@ -1247,12 +1233,12 @@ proc newCatchBody(ctx: var Ctx, info: TLineInfo): PNode {.inline.} =
       ctx.g.getSysMagic(info, "<", mLtI).newSymNode,
       ctx.newStateAccess(),
       newIntTypeNode(0, intTyp))
-    cond.typ() = boolTyp
+    cond.typ = boolTyp
 
     let negateState = newTree(nkCall,
       ctx.g.getSysMagic(info, "-", mUnaryMinusI).newSymNode,
       ctx.newStateAccess())
-    negateState.typ() = intTyp
+    negateState.typ = intTyp
 
     let ifBranch = newTree(nkElifBranch, cond, ctx.newStateAssgn(negateState))
     let ifStmt = newTree(nkIfStmt, ifBranch)
@@ -1277,18 +1263,30 @@ proc wrapIntoTryExcept(ctx: var Ctx, n: PNode): PNode {.inline.} =
 proc wrapIntoStateLoop(ctx: var Ctx, n: PNode): PNode =
   # while true:
   #   block :stateLoop:
+  #     gotoState :state
   #     local vars decl (if needed)
   #     body # Might get wrapped in try-except
   let loopBody = newNodeI(nkStmtList, n.info)
-  result = newTree(nkWhileStmt, ctx.g.boolLit(n.info, true), loopBody)
+  result = newTree(nkWhileStmt, newSymNode(ctx.g.getSysSym(n.info, "true")), loopBody)
   result.info = n.info
 
   let localVars = newNodeI(nkStmtList, n.info)
+  if not ctx.stateVarSym.isNil:
+    let varSect = newNodeI(nkVarSection, n.info)
+    addVar(varSect, newSymNode(ctx.stateVarSym))
+    localVars.add(varSect)
+
+    if not ctx.tempVars.isNil:
+      localVars.add(ctx.tempVars)
 
   let blockStmt = newNodeI(nkBlockStmt, n.info)
   blockStmt.add(newSymNode(ctx.stateLoopLabel))
 
-  var blockBody = newTree(nkStmtList, localVars, n)
+  let gs = newNodeI(nkGotoState, n.info)
+  gs.add(ctx.newStateAccess())
+  gs.add(ctx.g.newIntLit(n.info, ctx.states.len - 1))
+
+  var blockBody = newTree(nkStmtList, gs, localVars, n)
   if ctx.hasExceptions:
     blockBody = ctx.wrapIntoTryExcept(blockBody)
 
@@ -1301,28 +1299,29 @@ proc deleteEmptyStates(ctx: var Ctx) =
 
   # Apply new state indexes and mark unused states with -1
   var iValid = 0
-  for i, s in ctx.states.mpairs:
-    let body = skipStmtList(ctx, s.body)
+  for i, s in ctx.states:
+    let body = skipStmtList(ctx, s[1])
     if body.kind == nkGotoState and i != ctx.states.len - 1 and i != 0:
       # This is an empty state. Mark with -1.
-      s.label = emptyStateLabel
+      s[0].intVal = -1
     else:
-      s.label = iValid
+      s[0].intVal = iValid
       inc iValid
 
   for i, s in ctx.states:
-    let body = skipStmtList(ctx, s.body)
+    let body = skipStmtList(ctx, s[1])
     if body.kind != nkGotoState or i == 0:
-      discard ctx.skipThroughEmptyStates(s.body)
+      discard ctx.skipThroughEmptyStates(s)
       let excHandlState = ctx.exceptionTable[i]
       if excHandlState < 0:
         ctx.exceptionTable[i] = -ctx.skipEmptyStates(-excHandlState)
       elif excHandlState != 0:
         ctx.exceptionTable[i] = ctx.skipEmptyStates(excHandlState)
 
-  var i = 1 # ignore the entry and the exit
+  var i = 0
   while i < ctx.states.len - 1:
-    if ctx.states[i].label == emptyStateLabel:
+    let fs = skipStmtList(ctx, ctx.states[i][1])
+    if fs.kind == nkGotoState and i != 0:
       ctx.states.delete(i)
       ctx.exceptionTable.delete(i)
     else:
@@ -1431,67 +1430,18 @@ proc preprocess(c: var PreprocessContext; n: PNode): PNode =
     for i in 0 ..< n.len:
       result[i] = preprocess(c, n[i])
 
-proc detectCapturedVars(c: var Ctx, n: PNode, stateIdx: int) =
-  case n.kind
-  of nkSym:
-    let s = n.sym
-    if s.kind in {skResult, skVar, skLet, skForVar, skTemp} and sfGlobal notin s.flags and s.owner == c.fn:
-      let vs = c.varStates.getOrDefault(s.itemId, localNotSeen)
-      if vs == localNotSeen: # First seing this variable
-        c.varStates[s.itemId] = stateIdx
-      elif vs == localRequiresLifting:
-        discard # Sym already marked
-      elif vs != stateIdx:
-        c.captureVar(s)
-  of nkReturnStmt:
-    if n[0].kind in {nkAsgn, nkFastAsgn, nkSinkAsgn}:
-      # we have a `result = result` expression produced by the closure
-      # transform, let's not touch the LHS in order to make the lifting pass
-      # correct when `result` is lifted
-      detectCapturedVars(c, n[0][1], stateIdx)
-    else:
-      detectCapturedVars(c, n[0], stateIdx)
-  else:
-    for i in 0 ..< n.safeLen:
-      detectCapturedVars(c, n[i], stateIdx)
-
-proc detectCapturedVars(c: var Ctx) =
-  for i, s in c.states:
-    detectCapturedVars(c, s.body, i)
-
-proc liftLocals(c: var Ctx, n: PNode): PNode =
-  result = n
-  case n.kind
-  of nkSym:
-    let s = n.sym
-    if c.varStates.getOrDefault(s.itemId) == localRequiresLifting:
-      # lift
-      let e = getEnvParam(c.fn)
-      let field = getFieldFromObj(e.typ.elementType, s)
-      assert(field != nil)
-      result = rawIndirectAccess(newSymNode(e), field, n.info)
-    # elif c.varStates.getOrDefault(s.itemId, localNotSeen) != localNotSeen:
-    #   echo "Not lifting ", s.name.s
-
-  of nkReturnStmt:
-    if n[0].kind in {nkAsgn, nkFastAsgn, nkSinkAsgn}:
-      # we have a `result = result` expression produced by the closure
-      # transform, let's not touch the LHS in order to make the lifting pass
-      # correct when `result` is lifted
-      n[0][1] = liftLocals(c, n[0][1])
-    else:
-      n[0] = liftLocals(c, n[0])
-  else:
-    for i in 0 ..< n.safeLen:
-      n[i] = liftLocals(c, n[i])
-
 proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n: PNode): PNode =
-  var ctx = Ctx(g: g, fn: fn, idgen: idgen)
-
-  # The transformation should always happen after at least partial lambdalifting
-  # is performed, so that the closure iter environment is always created upfront.
-  doAssert(getEnvParam(fn) != nil, "Env param not created before iter transformation")
+  var ctx: Ctx
+  ctx.g = g
+  ctx.fn = fn
+  ctx.idgen = idgen
 
+  if getEnvParam(fn).isNil:
+    # Lambda lifting was not done yet. Use temporary :state sym, which will
+    # be handled specially by lambda lifting. Local temp vars (if needed)
+    # should follow the same logic.
+    ctx.stateVarSym = newSym(skVar, getIdent(ctx.g.cache, ":state"), idgen, fn, fn.info)
+    ctx.stateVarSym.typ = g.createClosureIterStateType(fn, idgen)
   ctx.stateLoopLabel = newSym(skLabel, getIdent(ctx.g.cache, ":stateLoop"), idgen, fn, fn.info)
   var pc = PreprocessContext(finallys: @[], config: g.config, idgen: idgen)
   var n = preprocess(pc, n.toStmtList)
@@ -1513,21 +1463,17 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
   # Optimize empty states away
   ctx.deleteEmptyStates()
 
-  let caseDispatcher = newTreeI(nkCaseStmt, n.info,
-      ctx.newStateAccess())
-
-  # Lamdalifting will not touch our locals, it is our responsibility to lift those that
-  # need it.
-  detectCapturedVars(ctx)
-
+  # Make new body by concatenating the list of states
+  result = newNodeI(nkStmtList, n.info)
   for s in ctx.states:
-    let body = ctx.transformStateAssignments(s.body)
-    caseDispatcher.add newTreeI(nkOfBranch, body.info, g.newIntLit(body.info, s.label), body)
+    assert(s.len == 2)
+    let body = s[1]
+    s.sons.del(1)
+    result.add(s)
+    result.add(body)
 
-  caseDispatcher.add newTreeI(nkElse, n.info, newTreeI(nkReturnStmt, n.info, g.emptyNode))
-
-  result = wrapIntoStateLoop(ctx, caseDispatcher)
-  result = liftLocals(ctx, result)
+  result = ctx.transformStateAssignments(result)
+  result = ctx.wrapIntoStateLoop(result)
 
   when false:
     echo "TRANSFORM TO STATES: "
@@ -1536,5 +1482,3 @@ proc transformClosureIterator*(g: ModuleGraph; idgen: IdGenerator; fn: PSym, n:
     echo "exception table:"
     for i, e in ctx.exceptionTable:
       echo i, " -> ", e
-
-    echo "ENV: ", renderTree(getEnvParam(fn).typ.elementType.n)

compiler/cmdlinehelper.nim

@@ -57,11 +57,6 @@ proc loadConfigsAndProcessCmdLine*(self: NimProg, cache: IdentCache; conf: Confi
   if conf.cmd == cmdNimscript:
     incl(conf.globalOptions, optWasNimscript)
   loadConfigs(DefaultConfig, cache, conf, graph.idgen) # load all config files
-  # restores `conf.notes` after loading config files
-  # because it has overwrites the notes when compiling the system module which
-  # is a foreign module compared to the project
-  if conf.cmd in cmdBackends:
-    conf.notes = conf.mainPackageNotes
 
   if not self.suggestMode:
     let scriptFile = conf.projectFull.changeFileExt("nims")

compiler/commands.nim

@@ -24,7 +24,7 @@ bootSwitch(usedMarkAndSweep, defined(gcmarkandsweep), "--gc:markAndSweep")
 bootSwitch(usedGoGC, defined(gogc), "--gc:go")
 bootSwitch(usedNoGC, defined(nogc), "--gc:none")
 
-import std/[setutils, os, strutils, parseutils, parseopt, sequtils, strtabs, enumutils]
+import std/[setutils, os, strutils, parseutils, parseopt, sequtils, strtabs]
 import
   msgs, options, nversion, condsyms, extccomp, platform,
   wordrecg, nimblecmd, lineinfos, pathutils
@@ -248,7 +248,6 @@ const
   errNoneSpeedOrSizeExpectedButXFound = "'none', 'speed' or 'size' expected, but '$1' found"
   errGuiConsoleOrLibExpectedButXFound = "'gui', 'console', 'lib' or 'staticlib' expected, but '$1' found"
   errInvalidExceptionSystem = "'goto', 'setjmp', 'cpp' or 'quirky' expected, but '$1' found"
-  errInvalidFeatureButXFound = Feature.toSeq.map(proc(val:Feature): string = "'$1'" % $val).join(", ") & " expected, but '$1' found"
 
 template warningOptionNoop(switch: string) =
   warningDeprecated(conf, info, "'$#' is deprecated, now a noop" % switch)
@@ -304,12 +303,6 @@ proc testCompileOptionArg*(conf: ConfigRef; switch, arg: string, info: TLineInfo
     else:
       result = false
       localError(conf, info, errInvalidExceptionSystem % arg)
-  of "experimental":
-    try:
-      result = conf.features.contains parseEnum[Feature](arg)
-    except ValueError:
-      result = false
-      localError(conf, info, errInvalidFeatureButXFound % arg)
   else:
     result = false
     invalidCmdLineOption(conf, passCmd1, switch, info)
@@ -469,6 +462,7 @@ proc handleCmdInput*(conf: ConfigRef) =
 proc parseCommand*(command: string): Command =
   case command.normalize
   of "c", "cc", "compile", "compiletoc": cmdCompileToC
+  of "nir": cmdCompileToNir
   of "cpp", "compiletocpp": cmdCompileToCpp
   of "objc", "compiletooc": cmdCompileToOC
   of "js", "compiletojs": cmdCompileToJS
@@ -506,6 +500,7 @@ proc setCmd*(conf: ConfigRef, cmd: Command) =
   of cmdCompileToCpp: conf.backend = backendCpp
   of cmdCompileToOC: conf.backend = backendObjc
   of cmdCompileToJS: conf.backend = backendJs
+  of cmdCompileToNir: conf.backend = backendNir
   else: discard
 
 proc setCommandEarly*(conf: ConfigRef, command: string) =

compiler/concepts.nim

@@ -11,7 +11,7 @@
 ## for details. Note this is a first implementation and only the "Concept matching"
 ## section has been implemented.
 
-import ast, semdata, lookups, lineinfos, idents, msgs, renderer, types, layeredtable
+import ast, astalgo, semdata, lookups, lineinfos, idents, msgs, renderer, types
 
 import std/intsets
 
@@ -96,7 +96,7 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
     ignorableForArgType = {tyVar, tySink, tyLent, tyOwned, tyGenericInst, tyAlias, tyInferred}
   case f.kind
   of tyAlias:
-    result = matchType(c, f.skipModifier, a, m)
+    result = matchType(c, f.lastSon, a, m)
   of tyTypeDesc:
     if isSelf(f):
       #let oldLen = m.inferred.len
@@ -105,19 +105,18 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
       #m.inferred.setLen oldLen
       #echo "A for ", result, " to ", typeToString(a), " to ", typeToString(m.potentialImplementation)
     else:
-      if a.kind == tyTypeDesc and f.hasElementType == a.hasElementType:
-        if f.hasElementType:
-          result = matchType(c, f.elementType, a.elementType, m)
-        else:
-          result = true # both lack it
+      if a.kind == tyTypeDesc and f.len == a.len:
+        for i in 0..<a.len:
+          if not matchType(c, f[i], a[i], m): return false
+        return true
       else:
         result = false
 
   of tyGenericInvocation:
     result = false
-    if a.kind == tyGenericInst and a.genericHead.kind == tyGenericBody:
-      if sameType(f.genericHead, a.genericHead) and f.kidsLen == a.kidsLen-1:
-        for i in FirstGenericParamAt ..< f.kidsLen:
+    if a.kind == tyGenericInst and a[0].kind == tyGenericBody:
+      if sameType(f[0], a[0]) and f.len == a.len-1:
+        for i in 1 ..< f.len:
           if not matchType(c, f[i], a[i], m): return false
         return true
   of tyGenericParam:
@@ -127,17 +126,17 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
     else:
       let old = existingBinding(m, f)
       if old == nil:
-        if f.hasElementType and f.elementType.kind != tyNone:
+        if f.len > 0 and f[0].kind != tyNone:
           # also check the generic's constraints:
           let oldLen = m.inferred.len
-          result = matchType(c, f.elementType, a, m)
+          result = matchType(c, f[0], a, m)
           m.inferred.setLen oldLen
           if result:
             when logBindings: echo "A adding ", f, " ", ak
             m.inferred.add((f, ak))
         elif m.magic == mArrGet and ak.kind in {tyArray, tyOpenArray, tySequence, tyVarargs, tyCstring, tyString}:
           when logBindings: echo "B adding ", f, " ", lastSon ak
-          m.inferred.add((f, last ak))
+          m.inferred.add((f, lastSon ak))
           result = true
         else:
           when logBindings: echo "C adding ", f, " ", ak
@@ -156,9 +155,9 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
     # modifiers in the concept must be there in the actual implementation
     # too but not vice versa.
     if a.kind == f.kind:
-      result = matchType(c, f.elementType, a.elementType, m)
+      result = matchType(c, f[0], a[0], m)
     elif m.magic == mArrPut:
-      result = matchType(c, f.elementType, a, m)
+      result = matchType(c, f[0], a, m)
     else:
       result = false
   of tyEnum, tyObject, tyDistinct:
@@ -168,7 +167,7 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
   of tyBool, tyChar, tyInt..tyUInt64:
     let ak = a.skipTypes(ignorableForArgType)
     result = ak.kind == f.kind or ak.kind == tyOrdinal or
-       (ak.kind == tyGenericParam and ak.hasElementType and ak.elementType.kind == tyOrdinal)
+       (ak.kind == tyGenericParam and ak.len > 0 and ak[0].kind == tyOrdinal)
   of tyConcept:
     let oldLen = m.inferred.len
     let oldPotentialImplementation = m.potentialImplementation
@@ -179,11 +178,10 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
       m.inferred.setLen oldLen
   of tyArray, tyTuple, tyVarargs, tyOpenArray, tyRange, tySequence, tyRef, tyPtr,
      tyGenericInst:
-    # ^ XXX Rewrite this logic, it's more complex than it needs to be.
     result = false
     let ak = a.skipTypes(ignorableForArgType - {f.kind})
-    if ak.kind == f.kind and f.kidsLen == ak.kidsLen:
-      for i in 0..<ak.kidsLen:
+    if ak.kind == f.kind and f.len == ak.len:
+      for i in 0..<ak.len:
         if not matchType(c, f[i], ak[i], m): return false
       return true
   of tyOr:
@@ -192,30 +190,30 @@ proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
       # say the concept requires 'int|float|string' if the potentialImplementation
       # says 'int|string' that is good enough.
       var covered = 0
-      for ff in f.kids:
-        for aa in a.kids:
+      for i in 0..<f.len:
+        for j in 0..<a.len:
           let oldLenB = m.inferred.len
-          let r = matchType(c, ff, aa, m)
+          let r = matchType(c, f[i], a[j], m)
           if r:
             inc covered
             break
           m.inferred.setLen oldLenB
 
-      result = covered >= a.kidsLen
+      result = covered >= a.len
       if not result:
         m.inferred.setLen oldLen
     else:
       result = false
-      for ff in f.kids:
-        result = matchType(c, ff, a, m)
+      for i in 0..<f.len:
+        result = matchType(c, f[i], a, m)
         if result: break # and remember the binding!
         m.inferred.setLen oldLen
   of tyNot:
     if a.kind == tyNot:
-      result = matchType(c, f.elementType, a.elementType, m)
+      result = matchType(c, f[0], a[0], m)
     else:
       let oldLen = m.inferred.len
-      result = not matchType(c, f.elementType, a, m)
+      result = not matchType(c, f[0], a, m)
       m.inferred.setLen oldLen
   of tyAnything:
     result = true
@@ -254,7 +252,7 @@ proc matchSym(c: PContext; candidate: PSym, n: PNode; m: var MatchCon): bool =
       m.inferred.setLen oldLen
       return false
 
-  if not matchReturnType(c, n[0].sym.typ.returnType, candidate.typ.returnType, m):
+  if not matchReturnType(c, n[0].sym.typ[0], candidate.typ[0], m):
     m.inferred.setLen oldLen
     return false
 
@@ -309,9 +307,9 @@ proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool =
     # error was reported earlier.
     result = false
 
-proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable; invocation: PType): bool =
+proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var TIdTable; invocation: PType): bool =
   ## Entry point from sigmatch. 'concpt' is the concept we try to match (here still a PType but
-  ## we extract its AST via 'concpt.n.lastSon'). 'arg' is the type that might fulfill the
+  ## we extract its AST via 'concpt.n.lastSon'). 'arg' is the type that might fullfill the
   ## concept's requirements. If so, we return true and fill the 'bindings' with pairs of
   ## (typeVar, instance) pairs. ('typeVar' is usually simply written as a generic 'T'.)
   ## 'invocation' can be nil for atomic concepts. For non-atomic concepts, it contains the
@@ -328,16 +326,16 @@ proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable
           dest = existingBinding(m, dest)
           if dest == nil or dest.kind != tyGenericParam: break
         if dest != nil:
-          bindings.put(a, dest)
+          bindings.idTablePut(a, dest)
           when logBindings: echo "A bind ", a, " ", dest
       else:
-        bindings.put(a, b)
+        bindings.idTablePut(a, b)
         when logBindings: echo "B bind ", a, " ", b
     # we have a match, so bind 'arg' itself to 'concpt':
-    bindings.put(concpt, arg)
+    bindings.idTablePut(concpt, arg)
     # invocation != nil means we have a non-atomic concept:
-    if invocation != nil and arg.kind == tyGenericInst and invocation.kidsLen == arg.kidsLen-1:
+    if invocation != nil and arg.kind == tyGenericInst and invocation.len == arg.len-1:
       # bind even more generic parameters
       assert invocation.kind == tyGenericInvocation
-      for i in FirstGenericParamAt ..< invocation.kidsLen:
-        bindings.put(invocation[i], arg[i])
+      for i in 1 ..< invocation.len:
+        bindings.idTablePut(invocation[i], arg[i])

compiler/condsyms.nim

@@ -157,7 +157,6 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimAllowNonVarDestructor")
   defineSymbol("nimHasQuirky")
   defineSymbol("nimHasEnsureMove")
-  defineSymbol("nimHasNoReturnError")
 
   defineSymbol("nimUseStrictDefs")
   defineSymbol("nimHasNolineTooLong")
@@ -166,8 +165,4 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasWarnStdPrefix")
 
   defineSymbol("nimHasVtables")
-  defineSymbol("nimHasGenericsOpenSym2")
-  defineSymbol("nimHasGenericsOpenSym3")
-  defineSymbol("nimHasJsNoLambdaLifting")
-  defineSymbol("nimHasDefaultFloatRoundtrip")
-  defineSymbol("nimHasXorSet")
+  defineSymbol("nimHasSeqsV3")

compiler/dfa.nim

@@ -46,10 +46,10 @@ type
     case isTryBlock: bool
     of false:
       label: PSym
-      breakFixups: seq[(TPosition, seq[PNode])] # Contains the gotos for the breaks along with their pending finales
+      breakFixups: seq[(TPosition, seq[PNode])] #Contains the gotos for the breaks along with their pending finales
     of true:
       finale: PNode
-      raiseFixups: seq[TPosition] # Contains the gotos for the raises
+      raiseFixups: seq[TPosition] #Contains the gotos for the raises
 
   Con = object
     code: ControlFlowGraph
@@ -181,6 +181,14 @@ proc genIf(c: var Con, n: PNode) =
     goto Lend3
   L3:
     D
+    goto Lend3 # not eliminated to simplify the join generation
+  Lend3:
+    join F3
+  Lend2:
+    join F2
+  Lend:
+    join F1
+
   ]#
   var endings: seq[TPosition] = @[]
   let oldInteresting = c.interestingInstructions
@@ -205,6 +213,7 @@ proc genAndOr(c: var Con; n: PNode) =
   #   fork lab1
   #   asgn dest, b
   # lab1:
+  #   join F1
   c.gen(n[1])
   forkT:
     c.gen(n[2])
@@ -315,7 +324,7 @@ proc genRaise(c: var Con; n: PNode) =
       if c.blocks[i].isTryBlock:
         genBreakOrRaiseAux(c, i, n)
         return
-    assert false # Unreachable
+    assert false #Unreachable
   else:
     genNoReturn(c)
 
@@ -371,7 +380,7 @@ proc genCall(c: var Con; n: PNode) =
   if t != nil: t = t.skipTypes(abstractInst)
   for i in 1..<n.len:
     gen(c, n[i])
-    if t != nil and i < t.signatureLen and isOutParam(t[i]):
+    if t != nil and i < t.len and isOutParam(t[i]):
       # Pass by 'out' is a 'must def'. Good enough for a move optimizer.
       genDef(c, n[i])
   # every call can potentially raise:
@@ -381,6 +390,7 @@ proc genCall(c: var Con; n: PNode) =
     # fork lab1
     # goto exceptionHandler (except or finally)
     # lab1:
+    # join F1
     forkT:
       for i in countdown(c.blocks.high, 0):
         if c.blocks[i].isTryBlock:

compiler/docgen.nim

@@ -115,7 +115,7 @@ proc add(dest: var ItemPre, str: string) = dest.add ItemFragment(isRst: false, s
 
 proc addRstFileIndex(d: PDoc, fileIndex: lineinfos.FileIndex): rstast.FileIndex =
   let invalid = rstast.FileIndex(-1)
-  result = d.nimToRstFid.getOrDefault(fileIndex, invalid)
+  result = d.nimToRstFid.getOrDefault(fileIndex, default = invalid)
   if result == invalid:
     let fname = toFullPath(d.conf, fileIndex)
     result = addFilename(d.sharedState, fname)
@@ -289,7 +289,7 @@ template declareClosures(currentFilename: AbsoluteFile, destFile: string) =
     let outDirPath: RelativeFile =
         presentationPath(conf, AbsoluteFile(basedir / targetRelPath))
           # use presentationPath because `..` path can be be mangled to `_._`
-    result = (string(conf.outDir / outDirPath), "")
+    result.targetPath = string(conf.outDir / outDirPath)
     if not fileExists(result.targetPath):
       # this can happen if targetRelPath goes to parent directory `OUTDIR/..`.
       # Trying it, this may cause ambiguities, but allows us to insert
@@ -830,8 +830,8 @@ proc getName(n: PNode): string =
   of nkAccQuoted:
     result = "`"
     for i in 0..<n.len: result.add(getName(n[i]))
-    result.add('`')
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+    result = "`"
+  of nkOpenSymChoice, nkClosedSymChoice:
     result = getName(n[0])
   else:
     result = ""
@@ -849,7 +849,7 @@ proc getNameIdent(cache: IdentCache; n: PNode): PIdent =
     var r = ""
     for i in 0..<n.len: r.add(getNameIdent(cache, n[i]).s)
     result = getIdent(cache, r)
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+  of nkOpenSymChoice, nkClosedSymChoice:
     result = getNameIdent(cache, n[0])
   else:
     result = nil
@@ -863,7 +863,7 @@ proc getRstName(n: PNode): PRstNode =
   of nkAccQuoted:
     result = getRstName(n[0])
     for i in 1..<n.len: result.text.add(getRstName(n[i]).text)
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+  of nkOpenSymChoice, nkClosedSymChoice:
     result = getRstName(n[0])
   else:
     result = nil
@@ -1000,9 +1000,8 @@ proc getTypeKind(n: PNode): string =
 proc toLangSymbol(k: TSymKind, n: PNode, baseName: string): LangSymbol =
   ## Converts symbol info (names/types/parameters) in `n` into format
   ## `LangSymbol` convenient for ``rst.nim``/``dochelpers.nim``.
-  result = LangSymbol(name: baseName.nimIdentNormalize,
-      symKind: k.toHumanStr
-  )
+  result.name = baseName.nimIdentNormalize
+  result.symKind = k.toHumanStr
   if k in routineKinds:
     var
       paramTypes: seq[string] = @[]
@@ -1031,7 +1030,7 @@ proc toLangSymbol(k: TSymKind, n: PNode, baseName: string): LangSymbol =
     if genNode != nil:
       var literal = ""
       var r: TSrcGen = initTokRender(genNode, {renderNoBody, renderNoComments,
-        renderNoPragmas, renderNoProcDefs, renderExpandUsing, renderNoPostfix})
+        renderNoPragmas, renderNoProcDefs, renderExpandUsing})
       var kind = tkEof
       while true:
         getNextTok(r, kind, literal)
@@ -1059,7 +1058,7 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
 
   # Obtain the plain rendered string for hyperlink titles.
   var r: TSrcGen = initTokRender(n, {renderNoBody, renderNoComments, renderDocComments,
-    renderNoPragmas, renderNoProcDefs, renderExpandUsing, renderNoPostfix})
+    renderNoPragmas, renderNoProcDefs, renderExpandUsing})
   while true:
     getNextTok(r, kind, literal)
     if kind == tkEof:
@@ -1086,9 +1085,6 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
     symbolOrIdEnc = encodeUrl(symbolOrId, usePlus = false)
     deprecationMsg = genDeprecationMsg(d, pragmaNode)
     rstLangSymbol = toLangSymbol(k, n, cleanPlainSymbol)
-    symNameNode =
-      if nameNode.kind == nkPostfix: nameNode[1]
-      else: nameNode
 
   # we generate anchors automatically for subsequent use in doc comments
   let lineinfo = rstast.TLineInfo(
@@ -1099,10 +1095,10 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
                priority = symbolPriority(k), info = lineinfo,
                module = addRstFileIndex(d, FileIndex d.module.position))
 
-  var renderFlags = {renderNoBody, renderNoComments, renderDocComments,
-    renderSyms, renderExpandUsing, renderNoPostfix}
-  if nonExports:
-    renderFlags.incl renderNonExportedFields
+  let renderFlags =
+    if nonExports: {renderNoBody, renderNoComments, renderDocComments, renderSyms,
+      renderExpandUsing, renderNonExportedFields}
+    else: {renderNoBody, renderNoComments, renderDocComments, renderSyms, renderExpandUsing}
   nodeToHighlightedHtml(d, n, result, renderFlags, symbolOrIdEnc)
 
   let seeSrc = genSeeSrc(d, toFullPath(d.conf, n.info), n.info.line.int)
@@ -1125,19 +1121,18 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
   let external = d.destFile.AbsoluteFile.relativeTo(d.conf.outDir, '/').changeFileExt(HtmlExt).string
 
   var attype = ""
-  if k in routineKinds and symNameNode.kind == nkSym:
+  if k in routineKinds and nameNode.kind == nkSym:
     let att = attachToType(d, nameNode.sym)
     if att != nil:
       attype = esc(d.target, att.name.s)
-  elif k == skType and symNameNode.kind == nkSym and
-      symNameNode.sym.typ.kind in {tyEnum, tyBool}:
-    let etyp = symNameNode.sym.typ
+  elif k == skType and nameNode.kind == nkSym and nameNode.sym.typ.kind in {tyEnum, tyBool}:
+    let etyp = nameNode.sym.typ
     for e in etyp.n:
       if e.sym.kind != skEnumField: continue
       let plain = renderPlainSymbolName(e)
       let symbolOrId = d.newUniquePlainSymbol(plain)
       setIndexTerm(d[], ieNim, htmlFile = external, id = symbolOrId,
-                   term = plain, linkTitle = symNameNode.sym.name.s & '.' & plain,
+                   term = plain, linkTitle = nameNode.sym.name.s & '.' & plain,
                    linkDesc = xmltree.escape(getPlainDocstring(e).docstringSummary),
                    line = n.info.line.int)
 
@@ -1158,8 +1153,8 @@ proc genItem(d: PDoc, n, nameNode: PNode, k: TSymKind, docFlags: DocFlags, nonEx
                linkTitle = detailedName,
                linkDesc = xmltree.escape(plainDocstring.docstringSummary),
                line = n.info.line.int)
-  if k == skType and symNameNode.kind == nkSym:
-    d.types.strTableAdd symNameNode.sym
+  if k == skType and nameNode.kind == nkSym:
+    d.types.strTableAdd nameNode.sym
 
 proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false): JsonItem =
   if not isVisible(d, nameNode): return
@@ -1167,14 +1162,12 @@ proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false):
     name = getNameEsc(d, nameNode)
     comm = genRecComment(d, n)
     r: TSrcGen
-    renderFlags = {renderNoBody, renderNoComments, renderDocComments,
-      renderExpandUsing, renderNoPostfix}
+    renderFlags = {renderNoBody, renderNoComments, renderDocComments, renderExpandUsing}
   if nonExports:
     renderFlags.incl renderNonExportedFields
   r = initTokRender(n, renderFlags)
-  result = JsonItem(json: %{ "name": %name, "type": %($k), "line": %n.info.line.int,
+  result.json = %{ "name": %name, "type": %($k), "line": %n.info.line.int,
                    "col": %n.info.col}
-  )
   if comm != nil:
     result.rst = comm
     result.rstField = "description"
@@ -1206,7 +1199,8 @@ proc genJsonItem(d: PDoc, n, nameNode: PNode, k: TSymKind, nonExports = false):
         var param = %{"name": %($genericParam)}
         if genericParam.sym.typ.len > 0:
           param["types"] = newJArray()
-          param["types"] = %($genericParam.sym.typ.elementType)
+        for kind in genericParam.sym.typ:
+          param["types"].add %($kind)
         result.json["signature"]["genericParams"].add param
   if optGenIndex in d.conf.globalOptions:
     genItem(d, n, nameNode, k, kForceExport)
@@ -1320,7 +1314,7 @@ proc documentEffect(cache: IdentCache; n, x: PNode, effectType: TSpecialWord, id
       if t.startsWith("ref "): t = substr(t, 4)
       effects[i] = newIdentNode(getIdent(cache, t), n.info)
       # set the type so that the following analysis doesn't screw up:
-      effects[i].typ() = real[i].typ
+      effects[i].typ = real[i].typ
 
     result = newTreeI(nkExprColonExpr, n.info,
       newIdentNode(getIdent(cache, $effectType), n.info), effects)
@@ -1406,8 +1400,7 @@ proc generateDoc*(d: PDoc, n, orig: PNode, config: ConfigRef, docFlags: DocFlags
     for it in n: traceDeps(d, it)
   of nkExportStmt:
     for it in n:
-      # bug #23051; don't generate documentation for exported symbols again
-      if it.kind == nkSym and sfExported notin it.sym.flags:
+      if it.kind == nkSym:
         if d.module != nil and d.module == it.sym.owner:
           generateDoc(d, it.sym.ast, orig, config, kForceExport)
         elif it.sym.ast != nil:

compiler/enumtostr.nim

@@ -63,8 +63,8 @@ proc searchObjCaseImpl(obj: PNode; field: PSym): PNode =
 
 proc searchObjCase(t: PType; field: PSym): PNode =
   result = searchObjCaseImpl(t.n, field)
-  if result == nil and t.baseClass != nil:
-    result = searchObjCase(t.baseClass.skipTypes({tyAlias, tyGenericInst, tyRef, tyPtr}), field)
+  if result == nil and t.len > 0:
+    result = searchObjCase(t[0].skipTypes({tyAlias, tyGenericInst, tyRef, tyPtr}), field)
   doAssert result != nil
 
 proc genCaseObjDiscMapping*(t: PType; field: PSym; info: TLineInfo; g: ModuleGraph; idgen: IdGenerator): PSym =

compiler/evalffi.nim

@@ -99,7 +99,7 @@ proc mapType(conf: ConfigRef, t: ast.PType): ptr libffi.Type =
      tyTyped, tyTypeDesc, tyProc, tyArray, tyStatic, tyNil:
     result = addr libffi.type_pointer
   of tyDistinct, tyAlias, tySink:
-    result = mapType(conf, t.skipModifier)
+    result = mapType(conf, t[0])
   else:
     result = nil
   # too risky:
@@ -126,16 +126,16 @@ proc packSize(conf: ConfigRef, v: PNode, typ: PType): int =
     if v.kind in {nkNilLit, nkPtrLit}:
       result = sizeof(pointer)
     else:
-      result = sizeof(pointer) + packSize(conf, v[0], typ.elementType)
+      result = sizeof(pointer) + packSize(conf, v[0], typ.lastSon)
   of tyDistinct, tyGenericInst, tyAlias, tySink:
-    result = packSize(conf, v, typ.skipModifier)
+    result = packSize(conf, v, typ[0])
   of tyArray:
     # consider: ptr array[0..1000_000, int] which is common for interfacing;
     # we use the real length here instead
     if v.kind in {nkNilLit, nkPtrLit}:
       result = sizeof(pointer)
     elif v.len != 0:
-      result = v.len * packSize(conf, v[0], typ.elementType)
+      result = v.len * packSize(conf, v[0], typ[1])
     else:
       result = 0
   else:
@@ -234,19 +234,19 @@ proc pack(conf: ConfigRef, v: PNode, typ: PType, res: pointer) =
         packRecCheck = 0
         globalError(conf, v.info, "cannot map value to FFI " & typeToString(v.typ))
       inc packRecCheck
-      pack(conf, v[0], typ.elementType, res +! sizeof(pointer))
+      pack(conf, v[0], typ.lastSon, res +! sizeof(pointer))
       dec packRecCheck
       awr(pointer, res +! sizeof(pointer))
   of tyArray:
-    let baseSize = getSize(conf, typ.elementType)
+    let baseSize = getSize(conf, typ[1])
     for i in 0..<v.len:
-      pack(conf, v[i], typ.elementType, res +! i * baseSize)
+      pack(conf, v[i], typ[1], res +! i * baseSize)
   of tyObject, tyTuple:
     packObject(conf, v, typ, res)
   of tyNil:
     discard
   of tyDistinct, tyGenericInst, tyAlias, tySink:
-    pack(conf, v, typ.skipModifier, res)
+    pack(conf, v, typ[0], res)
   else:
     globalError(conf, v.info, "cannot map value to FFI " & typeToString(v.typ))
 
@@ -275,7 +275,7 @@ proc unpackObject(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
   # the nkPar node:
   if n.isNil:
     result = newNode(nkTupleConstr)
-    result.typ() = typ
+    result.typ = typ
     if typ.n.isNil:
       internalError(conf, "cannot unpack unnamed tuple")
     unpackObjectAdd(conf, x, typ.n, result)
@@ -298,15 +298,15 @@ proc unpackObject(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
 proc unpackArray(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
   if n.isNil:
     result = newNode(nkBracket)
-    result.typ() = typ
+    result.typ = typ
     newSeq(result.sons, lengthOrd(conf, typ).toInt)
   else:
     result = n
     if result.kind != nkBracket:
       globalError(conf, n.info, "cannot map value from FFI")
-  let baseSize = getSize(conf, typ.elementType)
+  let baseSize = getSize(conf, typ[1])
   for i in 0..<result.len:
-    result[i] = unpack(conf, x +! i * baseSize, typ.elementType, result[i])
+    result[i] = unpack(conf, x +! i * baseSize, typ[1], result[i])
 
 proc canonNodeKind(k: TNodeKind): TNodeKind =
   case k
@@ -319,7 +319,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
   template aw(k, v, field: untyped): untyped =
     if n.isNil:
       result = newNode(k)
-      result.typ() = typ
+      result.typ = typ
     else:
       # check we have the right field:
       result = n
@@ -333,12 +333,12 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
   template setNil() =
     if n.isNil:
       result = newNode(nkNilLit)
-      result.typ() = typ
+      result.typ = typ
     else:
       reset n[]
       result = n
       result[] = TNode(kind: nkNilLit)
-      result.typ() = typ
+      result.typ = typ
 
   template awi(kind, v: untyped): untyped = aw(kind, v, intVal)
   template awf(kind, v: untyped): untyped = aw(kind, v, floatVal)
@@ -387,7 +387,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
       awi(nkPtrLit, cast[int](p))
     elif n != nil and n.len == 1:
       internalAssert(conf, n.kind == nkRefTy)
-      n[0] = unpack(conf, p, typ.elementType, n[0])
+      n[0] = unpack(conf, p, typ.lastSon, n[0])
       result = n
     else:
       result = nil
@@ -405,7 +405,7 @@ proc unpack(conf: ConfigRef, x: pointer, typ: PType, n: PNode): PNode =
   of tyNil:
     setNil()
   of tyDistinct, tyGenericInst, tyAlias, tySink:
-    result = unpack(conf, x, typ.skipModifier, n)
+    result = unpack(conf, x, typ.lastSon, n)
   else:
     # XXX what to do with 'array' here?
     result = nil
@@ -427,14 +427,14 @@ proc fficast*(conf: ConfigRef, x: PNode, destTyp: PType): PNode =
     # cast through a pointer needs a new inner object:
     let y = if x.kind == nkRefTy: newNodeI(nkRefTy, x.info, 1)
             else: x.copyTree
-    y.typ() = x.typ
+    y.typ = x.typ
     result = unpack(conf, a, destTyp, y)
     dealloc a
 
 proc callForeignFunction*(conf: ConfigRef, call: PNode): PNode =
   internalAssert conf, call[0].kind == nkPtrLit
 
-  var cif: TCif = default(TCif)
+  var cif: TCif
   var sig: ParamList = default(ParamList)
   # use the arguments' types for varargs support:
   for i in 1..<call.len:
@@ -444,7 +444,7 @@ proc callForeignFunction*(conf: ConfigRef, call: PNode): PNode =
 
   let typ = call[0].typ
   if prep_cif(cif, mapCallConv(conf, typ.callConv, call.info), cuint(call.len-1),
-              mapType(conf, typ.returnType), sig) != OK:
+              mapType(conf, typ[0]), sig) != OK:
     globalError(conf, call.info, "error in FFI call")
 
   var args: ArgList = default(ArgList)
@@ -453,15 +453,15 @@ proc callForeignFunction*(conf: ConfigRef, call: PNode): PNode =
     var t = call[i].typ
     args[i-1] = alloc0(packSize(conf, call[i], t))
     pack(conf, call[i], t, args[i-1])
-  let retVal = if isEmptyType(typ.returnType): pointer(nil)
-               else: alloc(getSize(conf, typ.returnType).int)
+  let retVal = if isEmptyType(typ[0]): pointer(nil)
+               else: alloc(getSize(conf, typ[0]).int)
 
   libffi.call(cif, fn, retVal, args)
 
   if retVal.isNil:
     result = newNode(nkEmpty)
   else:
-    result = unpack(conf, retVal, typ.returnType, nil)
+    result = unpack(conf, retVal, typ[0], nil)
     result.info = call.info
 
   if retVal != nil: dealloc retVal
@@ -474,14 +474,14 @@ proc callForeignFunction*(conf: ConfigRef, fn: PNode, fntyp: PType,
                           info: TLineInfo): PNode =
   internalAssert conf, fn.kind == nkPtrLit
 
-  var cif: TCif = default(TCif)
+  var cif: TCif
   var sig: ParamList = default(ParamList)
   for i in 0..len-1:
     var aTyp = args[i+start].typ
     if aTyp.isNil:
       internalAssert conf, i+1 < fntyp.len
       aTyp = fntyp[i+1]
-      args[i+start].typ() = aTyp
+      args[i+start].typ = aTyp
     sig[i] = mapType(conf, aTyp)
     if sig[i].isNil: globalError(conf, info, "cannot map FFI type")
 

compiler/evaltempl.nim

@@ -17,8 +17,8 @@ type
     owner, genSymOwner: PSym
     instLines: bool   # use the instantiation lines numbers
     isDeclarative: bool
-    mapping: SymMapping # every gensym'ed symbol needs to be mapped to some
-                        # new symbol
+    mapping: TIdTable # every gensym'ed symbol needs to be mapped to some
+                      # new symbol
     config: ConfigRef
     ic: IdentCache
     instID: int
@@ -33,19 +33,6 @@ proc evalTemplateAux(templ, actual: PNode, c: var TemplCtx, result: PNode) =
     let x = param
     if x.kind == nkArgList:
       for y in items(x): result.add(y)
-    elif nfDefaultRefsParam in x.flags:
-      # value of default param needs to be evaluated like template body
-      # if it contains other template params
-      var res: PNode
-      if isAtom(x):
-        res = newNodeI(nkPar, x.info)
-        evalTemplateAux(x, actual, c, res)
-        if res.len == 1: res = res[0]
-      else:
-        res = copyNode(x)
-        for i in 0..<x.safeLen:
-          evalTemplateAux(x[i], actual, c, res)
-      result.add res
     else:
       result.add copyTree(x)
 
@@ -57,19 +44,18 @@ proc evalTemplateAux(templ, actual: PNode, c: var TemplCtx, result: PNode) =
         handleParam actual[s.position]
       elif (s.owner != nil) and (s.kind == skGenericParam or
            s.kind == skType and s.typ != nil and s.typ.kind == tyGenericParam):
-        handleParam actual[s.owner.typ.signatureLen + s.position - 1]
+        handleParam actual[s.owner.typ.len + s.position - 1]
       else:
         internalAssert c.config, sfGenSym in s.flags or s.kind == skType
-        var x = idTableGet(c.mapping, s)
+        var x = PSym(idTableGet(c.mapping, s))
         if x == nil:
           x = copySym(s, c.idgen)
           # sem'check needs to set the owner properly later, see bug #9476
-          setOwner(x, nil) # c.genSymOwner
+          x.owner = nil # c.genSymOwner
           #if x.kind == skParam and x.owner.kind == skModule:
           #  internalAssert c.config, false
           idTablePut(c.mapping, s, x)
         if sfGenSym in s.flags:
-          # TODO: getIdent(c.ic, "`" & x.name.s & "`gensym" & $c.instID)
           result.add newIdentNode(getIdent(c.ic, x.name.s & "`gensym" & $c.instID),
             if c.instLines: actual.info else: templ.info)
         else:
@@ -130,7 +116,7 @@ proc evalTemplateArgs(n: PNode, s: PSym; conf: ConfigRef; fromHlo: bool): PNode
     # now that we have working untyped parameters.
     genericParams = if fromHlo: 0
                     else: s.ast[genericParamsPos].len
-    expectedRegularParams = s.typ.paramsLen
+    expectedRegularParams = s.typ.len-1
     givenRegularParams = totalParams - genericParams
   if givenRegularParams < 0: givenRegularParams = 0
 
@@ -182,7 +168,7 @@ proc wrapInComesFrom*(info: TLineInfo; sym: PSym; res: PNode): PNode =
     d.add newSymNode(sym, info)
     result.add d
     result.add res
-    result.typ() = res.typ
+    result.typ = res.typ
 
 proc evalTemplate*(n: PNode, tmpl, genSymOwner: PSym;
                    conf: ConfigRef;
@@ -196,14 +182,14 @@ proc evalTemplate*(n: PNode, tmpl, genSymOwner: PSym;
 
   # replace each param by the corresponding node:
   var args = evalTemplateArgs(n, tmpl, conf, fromHlo)
-  var ctx = TemplCtx(owner: tmpl,
-    genSymOwner: genSymOwner,
-    config: conf,
-    ic: ic,
-    mapping: initSymMapping(),
-    instID: instID[],
-    idgen: idgen
-  )
+  var ctx: TemplCtx
+  ctx.owner = tmpl
+  ctx.genSymOwner = genSymOwner
+  ctx.config = conf
+  ctx.ic = ic
+  ctx.mapping = initIdTable()
+  ctx.instID = instID[]
+  ctx.idgen = idgen
 
   let body = tmpl.ast[bodyPos]
   #echo "instantion of ", renderTree(body, {renderIds})

compiler/expanddefaults.nim

@@ -55,8 +55,8 @@ proc expandDefaultN(n: PNode; info: TLineInfo; res: PNode) =
     discard
 
 proc expandDefaultObj(t: PType; info: TLineInfo; res: PNode) =
-  if t.baseClass != nil:
-    expandDefaultObj(t.baseClass, info, res)
+  if t[0] != nil:
+    expandDefaultObj(t[0], info, res)
   expandDefaultN(t.n, info, res)
 
 proc expandDefault(t: PType; info: TLineInfo): PNode =
@@ -82,13 +82,13 @@ proc expandDefault(t: PType; info: TLineInfo): PNode =
     result = newZero(t, info, nkIntLit)
   of tyRange:
     # Could use low(T) here to finally fix old language quirks
-    result = expandDefault(skipModifier t, info)
+    result = expandDefault(t[0], info)
   of tyVoid: result = newZero(t, info, nkEmpty)
   of tySink, tyGenericInst, tyDistinct, tyAlias, tyOwned:
-    result = expandDefault(t.skipModifier, info)
+    result = expandDefault(t.lastSon, info)
   of tyOrdinal, tyGenericBody, tyGenericParam, tyInferred, tyStatic:
-    if t.hasElementType:
-      result = expandDefault(t.skipModifier, info)
+    if t.len > 0:
+      result = expandDefault(t.lastSon, info)
     else:
       result = newZero(t, info, nkEmpty)
   of tyFromExpr:
@@ -100,16 +100,16 @@ proc expandDefault(t: PType; info: TLineInfo): PNode =
     result = newZero(t, info, nkBracket)
     let n = toInt64(lengthOrd(nil, t))
     for i in 0..<n:
-      result.add expandDefault(t.elementType, info)
+      result.add expandDefault(t[1], info)
   of tyPtr, tyRef, tyProc, tyPointer, tyCstring:
     result = newZero(t, info, nkNilLit)
   of tyVar, tyLent:
-    let e = t.elementType
+    let e = t.lastSon
     if e.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
       # skip the modifier, `var openArray` is a (ptr, len) pair too:
       result = expandDefault(e, info)
     else:
-      result = newZero(e, info, nkNilLit)
+      result = newZero(t.lastSon, info, nkNilLit)
   of tySet:
     result = newZero(t, info, nkCurly)
   of tyObject:
@@ -118,14 +118,14 @@ proc expandDefault(t: PType; info: TLineInfo): PNode =
     expandDefaultObj(t, info, result)
   of tyTuple:
     result = newZero(t, info, nkTupleConstr)
-    for it in t.kids:
+    for it in t:
       result.add expandDefault(it, info)
   of tyVarargs, tyOpenArray, tySequence, tyUncheckedArray:
     result = newZero(t, info, nkBracket)
   of tyString:
     result = newZero(t, info, nkStrLit)
   of tyNone, tyEmpty, tyUntyped, tyTyped, tyTypeDesc,
-     tyNil, tyGenericInvocation, tyError, tyBuiltInTypeClass,
+     tyNil, tyGenericInvocation, tyProxy, tyBuiltInTypeClass,
      tyUserTypeClass, tyUserTypeClassInst, tyCompositeTypeClass,
      tyAnd, tyOr, tyNot, tyAnything, tyConcept, tyIterable, tyForward:
     result = newZero(t, info, nkEmpty) # bug indicator

compiler/extccomp.nim

@@ -19,7 +19,7 @@ import std/[os, osproc, streams, sequtils, times, strtabs, json, jsonutils, suga
 import std / strutils except addf
 
 when defined(nimPreviewSlimSystem):
-  import std/[syncio, assertions]
+  import std/syncio
 
 import ../dist/checksums/src/checksums/sha1
 
@@ -63,7 +63,7 @@ type
 
 # Configuration settings for various compilers.
 # When adding new compilers, the cmake sources could be a good reference:
-# https://cmake.org/gitweb?p=cmake.git;a=tree;f=Modules/Platform;
+# http://cmake.org/gitweb?p=cmake.git;a=tree;f=Modules/Platform;
 
 template compiler(name, settings: untyped): untyped =
   proc name: TInfoCC {.compileTime.} = settings
@@ -162,11 +162,7 @@ compiler vcc:
     linkerExe: "cl",
     linkTmpl: "$builddll$vccplatform /Fe$exefile $objfiles $buildgui /nologo $options",
     includeCmd: " /I",
-    # HACK: we call `cl` so we have to pass `/link` for linker options,
-    # but users may still want to pass arguments to `cl` (see #14221)
-    # to deal with this, we add `/link` before each `/LIBPATH`,
-    # the linker ignores extra `/link`s since it's an unrecognized argument
-    linkDirCmd: " /link /LIBPATH:",
+    linkDirCmd: " /LIBPATH:",
     linkLibCmd: " $1.lib",
     debug: " /RTC1 /Z7 ",
     pic: "",
@@ -176,22 +172,6 @@ compiler vcc:
     cppXsupport: "",
     props: {hasCpp, hasAssume, hasDeclspec})
 
-# Nvidia CUDA NVCC Compiler
-compiler nvcc:
-  result = gcc()
-  result.name = "nvcc"
-  result.compilerExe = "nvcc"
-  result.cppCompiler = "nvcc"
-  result.compileTmpl = "-c -x cu -Xcompiler=\"$options\" $include -o $objfile $file"
-  result.linkTmpl = "$buildgui $builddll -o $exefile $objfiles -Xcompiler=\"$options\""
-
-# AMD HIPCC Compiler (rocm/cuda)
-compiler hipcc:
-  result = clang()
-  result.name = "hipcc"
-  result.compilerExe = "hipcc"
-  result.cppCompiler = "hipcc"
-
 compiler clangcl:
   result = vcc()
   result.name = "clang_cl"
@@ -305,9 +285,7 @@ const
     envcc(),
     icl(),
     icc(),
-    clangcl(),
-    hipcc(),
-    nvcc()]
+    clangcl()]
 
   hExt* = ".h"
 
@@ -341,7 +319,7 @@ proc getConfigVar(conf: ConfigRef; c: TSystemCC, suffix: string): string =
   var fullSuffix = suffix
   case conf.backend
   of backendCpp, backendJs, backendObjc: fullSuffix = "." & $conf.backend & suffix
-  of backendC: discard
+  of backendC, backendNir: discard
   of backendInvalid:
     # during parsing of cfg files; we don't know the backend yet, no point in
     # guessing wrong thing
@@ -781,7 +759,7 @@ proc getLinkCmd(conf: ConfigRef; output: AbsoluteFile,
     # https://blog.molecular-matters.com/2017/05/09/deleting-pdb-files-locked-by-visual-studio/
     # and a bit about the .pdb format in case that is ever needed:
     # https://github.com/crosire/blink
-    # https://www.debuginfo.com/articles/debuginfomatch.html#pdbfiles
+    # http://www.debuginfo.com/articles/debuginfomatch.html#pdbfiles
     if conf.hcrOn and isVSCompatible(conf):
       let t = now()
       let pdb = output.string & "." & format(t, "MMMM-yyyy-HH-mm-") & $t.nanosecond & ".pdb"
@@ -1004,11 +982,10 @@ proc jsonBuildInstructionsFile*(conf: ConfigRef): AbsoluteFile =
   # works out of the box with `hashMainCompilationParams`.
   result = getNimcacheDir(conf) / conf.outFile.changeFileExt("json")
 
-const cacheVersion = "D20240927T193831" # update when `BuildCache` spec changes
+const cacheVersion = "D20210525T193831" # update when `BuildCache` spec changes
 type BuildCache = object
   cacheVersion: string
   outputFile: string
-  outputLastModificationTime: string
   compile: seq[(string, string)]
   link: seq[string]
   linkcmd: string
@@ -1022,7 +999,7 @@ type BuildCache = object
   depfiles: seq[(string, string)]
   nimexe: string
 
-proc writeJsonBuildInstructions*(conf: ConfigRef; deps: StringTableRef) =
+proc writeJsonBuildInstructions*(conf: ConfigRef) =
   var linkFiles = collect(for it in conf.externalToLink:
     var it = it
     if conf.noAbsolutePaths: it = it.extractFilename
@@ -1043,17 +1020,11 @@ proc writeJsonBuildInstructions*(conf: ConfigRef; deps: StringTableRef) =
     currentDir: getCurrentDir())
   if optRun in conf.globalOptions or isDefined(conf, "nimBetterRun"):
     bcache.cmdline = conf.commandLine
-    for it in conf.m.fileInfos:
+    bcache.depfiles = collect(for it in conf.m.fileInfos:
       let path = it.fullPath.string
       if isAbsolute(path): # TODO: else?
-        if path in deps:
-          bcache.depfiles.add (path, deps[path])
-        else: # backup for configs etc.
-          bcache.depfiles.add (path, $secureHashFile(path))
-
+        (path, $secureHashFile(path)))
     bcache.nimexe = hashNimExe()
-    if fileExists(bcache.outputFile):
-      bcache.outputLastModificationTime = $getLastModificationTime(bcache.outputFile)
   conf.jsonBuildFile = conf.jsonBuildInstructionsFile
   conf.jsonBuildFile.string.writeFile(bcache.toJson.pretty)
 
@@ -1074,8 +1045,6 @@ proc changeDetectedViaJsonBuildInstructions*(conf: ConfigRef; jsonFile: Absolute
     # xxx optimize by returning false if stdin input was the same
   for (file, hash) in bcache.depfiles:
     if $secureHashFile(file) != hash: return true
-  if bcache.outputLastModificationTime != $getLastModificationTime(bcache.outputFile):
-    return true
 
 proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
   var bcache: BuildCache = default(BuildCache)
@@ -1092,7 +1061,7 @@ proc runJsonBuildInstructions*(conf: ConfigRef; jsonFile: AbsoluteFile) =
       "jsonscript command outputFile '$1' must match '$2' which was specified during --compileOnly, see \"outputFile\" entry in '$3' " %
       [outputCurrent, output, jsonFile.string])
   var cmds: TStringSeq = default(TStringSeq)
-  var prettyCmds: TStringSeq = default(TStringSeq)
+  var prettyCmds: TStringSeq= default(TStringSeq)
   let prettyCb = proc (idx: int) = writePrettyCmdsStderr(prettyCmds[idx])
   for (name, cmd) in bcache.compile:
     cmds.add cmd

compiler/guards.nim

@@ -1063,7 +1063,7 @@ proc pleViaModel(model: TModel; aa, bb: PNode): TImplication =
       let b = fact[2]
       if a.kind == nkSym: replacements.add((a,b))
       else: replacements.add((b,a))
-  var m = TModel()
+  var m: TModel
   var a = aa
   var b = bb
   if replacements.len > 0:
@@ -1104,7 +1104,7 @@ proc settype(n: PNode): PType =
 
 proc buildOf(it, loc: PNode; o: Operators): PNode =
   var s = newNodeI(nkCurly, it.info, it.len-1)
-  s.typ() = settype(loc)
+  s.typ = settype(loc)
   for i in 0..<it.len-1: s[i] = it[i]
   result = newNodeI(nkCall, it.info, 3)
   result[0] = newSymNode(o.opContains)
@@ -1165,12 +1165,8 @@ proc buildProperFieldCheck(access, check: PNode; o: Operators): PNode =
   if check[1].kind == nkCurly:
     result = copyTree(check)
     if access.kind == nkDotExpr:
-      # change the access to the discriminator field access
       var a = copyTree(access)
-      # set field name to discriminator field name
       a[1] = check[2]
-      # set discriminator field type: important for `neg`
-      a.typ() = check[2].typ
       result[2] = a
       # 'access.kind != nkDotExpr' can happen for object constructors
       # which we don't check yet

compiler/ic/ic.nim

@@ -16,7 +16,7 @@ from std/os import removeFile, isAbsolute
 
 import ../../dist/checksums/src/checksums/sha1
 
-import iclineinfos
+import ".." / nir / nirlineinfos
 
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions, formatfloat]
@@ -59,8 +59,8 @@ type
     emittedTypeInfo*: seq[string]
     backendFlags*: set[ModuleBackendFlag]
 
-    syms*: OrderedTable[int32, PackedSym]
-    types*: OrderedTable[int32, PackedType]
+    syms*: seq[PackedSym]
+    types*: seq[PackedType]
     strings*: BiTable[string] # we could share these between modules.
     numbers*: BiTable[BiggestInt] # we also store floats in here so
                                   # that we can assure that every bit is kept
@@ -362,15 +362,15 @@ proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemI
   result = PackedItemId(module: toLitId(t.uniqueId.module.FileIndex, c, m), item: t.uniqueId.item)
 
   if t.uniqueId.module == c.thisModule and not c.typeMarker.containsOrIncl(t.uniqueId.item):
-    #if t.uniqueId.item >= m.types.len:
-    #  setLen m.types, t.uniqueId.item+1
+    if t.uniqueId.item >= m.types.len:
+      setLen m.types, t.uniqueId.item+1
 
-    var p = PackedType(id: t.uniqueId.item, kind: t.kind, flags: t.flags, callConv: t.callConv,
+    var p = PackedType(kind: t.kind, flags: t.flags, callConv: t.callConv,
       size: t.size, align: t.align, nonUniqueId: t.itemId.item,
       paddingAtEnd: t.paddingAtEnd)
     storeNode(p, t, n)
     p.typeInst = t.typeInst.storeType(c, m)
-    for kid in kids t:
+    for kid in items t:
       p.types.add kid.storeType(c, m)
     c.addMissing t.sym
     p.sym = t.sym.safeItemId(c, m)
@@ -383,9 +383,10 @@ proc storeType(t: PType; c: var PackedEncoder; m: var PackedModule): PackedItemI
 proc toPackedLib(l: PLib; c: var PackedEncoder; m: var PackedModule): PackedLib =
   ## the plib hangs off the psym via the .annex field
   if l.isNil: return
-  result = PackedLib(kind: l.kind, generated: l.generated,
-    isOverridden: l.isOverridden, name: toLitId($l.name, m)
-  )
+  result.kind = l.kind
+  result.generated = l.generated
+  result.isOverridden = l.isOverridden
+  result.name = toLitId($l.name, m)
   storeNode(result, l, path)
 
 proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId =
@@ -396,12 +397,12 @@ proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
   result = PackedItemId(module: toLitId(s.itemId.module.FileIndex, c, m), item: s.itemId.item)
 
   if s.itemId.module == c.thisModule and not c.symMarker.containsOrIncl(s.itemId.item):
-    #if s.itemId.item >= m.syms.len:
-    #  setLen m.syms, s.itemId.item+1
+    if s.itemId.item >= m.syms.len:
+      setLen m.syms, s.itemId.item+1
 
     assert sfForward notin s.flags
 
-    var p = PackedSym(id: s.itemId.item, kind: s.kind, flags: s.flags, info: s.info.toPackedInfo(c, m), magic: s.magic,
+    var p = PackedSym(kind: s.kind, flags: s.flags, info: s.info.toPackedInfo(c, m), magic: s.magic,
       position: s.position, offset: s.offset, disamb: s.disamb, options: s.options,
       name: s.name.s.toLitId(m))
 
@@ -414,7 +415,7 @@ proc storeSym*(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId
       p.bitsize = s.bitsize
       p.alignment = s.alignment
 
-    p.externalName = toLitId(s.loc.snippet, m)
+    p.externalName = toLitId(s.loc.r, m)
     p.locFlags = s.loc.flags
     c.addMissing s.typ
     p.typ = s.typ.storeType(c, m)
@@ -433,11 +434,11 @@ proc addModuleRef(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var Pac
   let info = n.info.toPackedInfo(c, m)
   if n.typ != n.sym.typ:
     ir.addNode(kind = nkModuleRef, operand = 3.int32, # spans 3 nodes in total
-               info = info, flags = n.flags,
+               info = info,
                typeId = storeTypeLater(n.typ, c, m))
   else:
     ir.addNode(kind = nkModuleRef, operand = 3.int32, # spans 3 nodes in total
-              info = info, flags = n.flags)
+              info = info)
   ir.addNode(kind = nkNone, info = info,
              operand = toLitId(n.sym.itemId.module.FileIndex, c, m).int32)
   ir.addNode(kind = nkNone, info = info,
@@ -613,10 +614,6 @@ proc loadRodFile*(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef
     f.loadSection section
     f.loadSeq data
 
-  template loadTableSection(section, data) {.dirty.} =
-    f.loadSection section
-    f.loadOrderedTable data
-
   template loadTabSection(section, data) {.dirty.} =
     f.loadSection section
     f.load data
@@ -649,8 +646,8 @@ proc loadRodFile*(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef
     loadTabSection topLevelSection, m.topLevel
 
     loadTabSection bodiesSection, m.bodies
-    loadTableSection symsSection, m.syms
-    loadTableSection typesSection, m.types
+    loadSeqSection symsSection, m.syms
+    loadSeqSection typesSection, m.types
 
     loadSeqSection typeInstCacheSection, m.typeInstCache
     loadSeqSection procInstCacheSection, m.procInstCache
@@ -695,10 +692,6 @@ proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var Pac
     f.storeSection section
     f.store data
 
-  template storeTableSection(section, data) {.dirty.} =
-    f.storeSection section
-    f.storeOrderedTable data
-
   storeTabSection stringsSection, m.strings
 
   storeSeqSection checkSumsSection, m.includes
@@ -722,9 +715,9 @@ proc saveRodFile*(filename: AbsoluteFile; encoder: var PackedEncoder; m: var Pac
   storeTabSection topLevelSection, m.topLevel
 
   storeTabSection bodiesSection, m.bodies
-  storeTableSection symsSection, m.syms
+  storeSeqSection symsSection, m.syms
 
-  storeTableSection typesSection, m.types
+  storeSeqSection typesSection, m.types
 
   storeSeqSection typeInstCacheSection, m.typeInstCache
   storeSeqSection procInstCacheSection, m.procInstCache
@@ -775,8 +768,8 @@ type
     status*: ModuleStatus
     symsInit, typesInit, loadedButAliveSetChanged*: bool
     fromDisk*: PackedModule
-    syms: OrderedTable[int32, PSym] # indexed by itemId
-    types: OrderedTable[int32, PType]
+    syms: seq[PSym] # indexed by itemId
+    types: seq[PType]
     module*: PSym # the one true module symbol.
     iface, ifaceHidden: Table[PIdent, seq[PackedItemId]]
       # PackedItemId so that it works with reexported symbols too
@@ -837,8 +830,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
     result.ident = getIdent(c.cache, g[thisModule].fromDisk.strings[n.litId])
   of nkSym:
     result.sym = loadSym(c, g, thisModule, PackedItemId(module: LitId(0), item: tree[n].soperand))
-    if result.typ == nil:
-      result.typ() = result.sym.typ
+    if result.typ == nil: result.typ = result.sym.typ
   of externIntLit:
     result.intVal = g[thisModule].fromDisk.numbers[n.litId]
   of nkStrLit..nkTripleStrLit:
@@ -851,8 +843,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
     assert n2.kind == nkNone
     transitionNoneToSym(result)
     result.sym = loadSym(c, g, thisModule, PackedItemId(module: n1.litId, item: tree[n2].soperand))
-    if result.typ == nil:
-      result.typ() = result.sym.typ
+    if result.typ == nil: result.typ = result.sym.typ
   else:
     for n0 in sonsReadonly(tree, n):
       result.addAllowNil loadNodes(c, g, thisModule, tree, n0)
@@ -942,10 +933,10 @@ proc symBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
     result.guard = loadSym(c, g, si, s.guard)
     result.bitsize = s.bitsize
     result.alignment = s.alignment
-  setOwner(result, loadSym(c, g, si, s.owner))
+  result.owner = loadSym(c, g, si, s.owner)
   let externalName = g[si].fromDisk.strings[s.externalName]
   if externalName != "":
-    result.loc.snippet = externalName
+    result.loc.r = rope externalName
   result.loc.flags = s.locFlags
   result.instantiatedFrom = loadSym(c, g, si, s.instantiatedFrom)
 
@@ -969,11 +960,11 @@ proc loadSym(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; s:
         loadToReplayNodes(g, c.config, c.cache, m, g[int m])
 
     assert g[si].status in {loaded, storing, stored}
-    #if not g[si].symsInit:
-    #  g[si].symsInit = true
-    #  setLen g[si].syms, g[si].fromDisk.syms.len
+    if not g[si].symsInit:
+      g[si].symsInit = true
+      setLen g[si].syms, g[si].fromDisk.syms.len
 
-    if g[si].syms.getOrDefault(s.item) == nil:
+    if g[si].syms[s.item] == nil:
       if g[si].fromDisk.syms[s.item].kind != skModule:
         result = symHeaderFromPacked(c, g, g[si].fromDisk.syms[s.item], si, s.item)
         # store it here early on, so that recursions work properly:
@@ -998,7 +989,7 @@ proc typeHeaderFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
 proc typeBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
                         t: PackedType; si, item: int32; result: PType) =
   result.sym = loadSym(c, g, si, t.sym)
-  setOwner(result, loadSym(c, g, si, t.owner))
+  result.owner = loadSym(c, g, si, t.owner)
   when false:
     for op, item in pairs t.attachedOps:
       result.attachedOps[op] = loadSym(c, g, si, item)
@@ -1020,11 +1011,11 @@ proc loadType(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; t
     assert g[si].status in {loaded, storing, stored}
     assert t.item > 0
 
-    #if not g[si].typesInit:
-    #  g[si].typesInit = true
-    #  setLen g[si].types, g[si].fromDisk.types.len
+    if not g[si].typesInit:
+      g[si].typesInit = true
+      setLen g[si].types, g[si].fromDisk.types.len
 
-    if g[si].types.getOrDefault(t.item) == nil:
+    if g[si].types[t.item] == nil:
       result = typeHeaderFromPacked(c, g, g[si].fromDisk.types[t.item], si, t.item)
       # store it here early on, so that recursions work properly:
       g[si].types[t.item] = result
@@ -1062,7 +1053,7 @@ proc setupLookupTables(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCa
                   name: getIdent(cache, splitFile(filename).name),
                   info: newLineInfo(fileIdx, 1, 1),
                   position: int(fileIdx))
-  setOwner(m.module, getPackage(conf, cache, fileIdx))
+  m.module.owner = getPackage(conf, cache, fileIdx)
   m.module.flags = m.fromDisk.moduleFlags
 
 proc loadToReplayNodes(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;
@@ -1163,7 +1154,10 @@ proc loadProcBody*(config: ConfigRef, cache: IdentCache;
 proc loadTypeFromId*(config: ConfigRef, cache: IdentCache;
                      g: var PackedModuleGraph; module: int; id: PackedItemId): PType =
   bench g.loadType:
-    result = g[module].types.getOrDefault(id.item)
+    if id.item < g[module].types.len:
+      result = g[module].types[id.item]
+    else:
+      result = nil
     if result == nil:
       var decoder = PackedDecoder(
         lastModule: int32(-1),
@@ -1176,7 +1170,10 @@ proc loadTypeFromId*(config: ConfigRef, cache: IdentCache;
 proc loadSymFromId*(config: ConfigRef, cache: IdentCache;
                     g: var PackedModuleGraph; module: int; id: PackedItemId): PSym =
   bench g.loadSym:
-    result = g[module].syms.getOrDefault(id.item)
+    if id.item < g[module].syms.len:
+      result = g[module].syms[id.item]
+    else:
+      result = nil
     if result == nil:
       var decoder = PackedDecoder(
         lastModule: int32(-1),
@@ -1192,6 +1189,19 @@ proc translateId*(id: PackedItemId; g: PackedModuleGraph; thisModule: int; confi
   else:
     ItemId(module: toFileIndex(id.module, g[thisModule].fromDisk, config).int32, item: id.item)
 
+proc checkForHoles(m: PackedModule; config: ConfigRef; moduleId: int) =
+  var bugs = 0
+  for i in 1 .. high(m.syms):
+    if m.syms[i].kind == skUnknown:
+      echo "EMPTY ID ", i, " module ", moduleId, " ", toFullPath(config, FileIndex(moduleId))
+      inc bugs
+  assert bugs == 0
+  when false:
+    var nones = 0
+    for i in 1 .. high(m.types):
+      inc nones, m.types[i].kind == tyNone
+    assert nones < 1
+
 proc simulateLoadedModule*(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;
                            moduleSym: PSym; m: PackedModule) =
   # For now only used for heavy debugging. In the future we could use this to reduce the

compiler/ic/integrity.nim

@@ -10,7 +10,7 @@
 ## Integrity checking for a set of .rod files.
 ## The set must cover a complete Nim project.
 
-import std/[sets, tables]
+import std/sets
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -108,18 +108,18 @@ proc checkModule(c: var CheckedContext; m: PackedModule) =
   # We check that:
   # - Every symbol references existing types and symbols.
   # - Every tree node references existing types and symbols.
-  for _, v in pairs(m.syms):
-    checkLocalSym c, v.id
+  for i in 0..high(m.syms):
+    checkLocalSym c, int32(i)
 
   checkTree c, m.toReplay
   checkTree c, m.topLevel
 
   for e in m.exports:
-    #assert e[1] >= 0 and e[1] < m.syms.len
+    assert e[1] >= 0 and e[1] < m.syms.len
     assert e[0] == m.syms[e[1]].name
 
   for e in m.compilerProcs:
-    #assert e[1] >= 0 and e[1] < m.syms.len
+    assert e[1] >= 0 and e[1] < m.syms.len
     assert e[0] == m.syms[e[1]].name
 
   checkLocalSymIds c, m, m.converters

compiler/ic/navigator.nim

@@ -11,7 +11,7 @@
 ## IDE-like features. It uses the set of .rod files to accomplish
 ## its task. The set must cover a complete Nim project.
 
-import std/[sets, tables]
+import std/sets
 
 from std/os import nil
 from std/private/miscdollars import toLocation
@@ -20,7 +20,7 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 import ".." / [ast, modulegraphs, msgs, options]
-import iclineinfos
+import ".." / nir / nirlineinfos
 import packed_ast, bitabs, ic
 
 type

compiler/ic/packed_ast.nim

@@ -16,7 +16,7 @@ import std/[hashes, tables, strtabs]
 import bitabs, rodfiles
 import ".." / [ast, options]
 
-import iclineinfos
+import ".." / nir / nirlineinfos
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -47,7 +47,6 @@ type
     path*: NodeId
 
   PackedSym* = object
-    id*: int32
     kind*: TSymKind
     name*: LitId
     typ*: PackedItemId
@@ -72,7 +71,6 @@ type
     instantiatedFrom*: PackedItemId
 
   PackedType* = object
-    id*: int32
     kind*: TTypeKind
     callConv*: TCallingConvention
     #nodekind*: TNodeKind
@@ -126,7 +124,7 @@ proc `==`*(a, b: NodePos): bool {.borrow.}
 proc `==`*(a, b: NodeId): bool {.borrow.}
 
 proc newTreeFrom*(old: PackedTree): PackedTree =
-  result = PackedTree(nodes: @[])
+  result.nodes = @[]
   when false: result.sh = old.sh
 
 proc addIdent*(tree: var PackedTree; s: LitId; info: PackedLineInfo) =

compiler/ic/rodfiles.nim

@@ -19,8 +19,6 @@ from std/typetraits import supportsCopyMem
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions]
 
-import std / tables
-
 ## Overview
 ## ========
 ## `RodFile` represents a Rod File (versioned binary format), and the
@@ -172,18 +170,6 @@ proc storeSeq*[T](f: var RodFile; s: seq[T]) =
     for i in 0..<s.len:
       storePrim(f, s[i])
 
-proc storeOrderedTable*[K, T](f: var RodFile; s: OrderedTable[K, T]) =
-  if f.err != ok: return
-  if s.len >= high(int32):
-    setError f, tooBig
-    return
-  var lenPrefix = int32(s.len)
-  if writeBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    for _, v in s:
-      storePrim(f, v)
-
 proc loadPrim*(f: var RodFile; s: var string) =
   ## Read a string, the length was stored as a prefix
   if f.err != ok: return
@@ -225,19 +211,6 @@ proc loadSeq*[T](f: var RodFile; s: var seq[T]) =
     for i in 0..<lenPrefix:
       loadPrim(f, s[i])
 
-proc loadOrderedTable*[K, T](f: var RodFile; s: var OrderedTable[K, T]) =
-  ## `T` must be compatible with `copyMem`, see `loadPrim`
-  if f.err != ok: return
-  var lenPrefix = int32(0)
-  if readBuffer(f.f, addr lenPrefix, sizeof(lenPrefix)) != sizeof(lenPrefix):
-    setError f, ioFailure
-  else:
-    s = initOrderedTable[K, T](lenPrefix)
-    for i in 0..<lenPrefix:
-      var x = default T
-      loadPrim(f, x)
-      s[x.id] = x
-
 proc storeHeader*(f: var RodFile; cookie = defaultCookie) =
   ## stores the header which is described by `cookie`.
   if f.err != ok: return

compiler/importer.nim

@@ -144,7 +144,7 @@ proc importSymbol(c: PContext, n: PNode, fromMod: PSym; importSet: var IntSet) =
     # for an enumeration we have to add all identifiers
     if multiImport:
       # for a overloadable syms add all overloaded routines
-      var it: ModuleIter = default(ModuleIter)
+      var it: ModuleIter
       var e = initModuleIter(it, c.graph, fromMod, s.name)
       while e != nil:
         if e.name.id != s.name.id: internalError(c.config, n.info, "importSymbol: 3")
@@ -246,14 +246,12 @@ proc importModuleAs(c: PContext; n: PNode, realModule: PSym, importHidden: bool)
     result = createModuleAliasImpl(realModule.name)
   if importHidden:
     result.options.incl optImportHidden
-  let moduleIdent = if n.kind == nkInfix: n[^1] else: n
-  c.unusedImports.add((result, moduleIdent.info))
+  c.unusedImports.add((result, n.info))
   c.importModuleMap[result.id] = realModule.id
   c.importModuleLookup.mgetOrPut(result.name.id, @[]).addUnique realModule.id
 
 proc transformImportAs(c: PContext; n: PNode): tuple[node: PNode, importHidden: bool] =
-  result = (nil, false)
-  var ret = default(typeof(result))
+  var ret: typeof(result)
   proc processPragma(n2: PNode): PNode =
     let (result2, kws) = splitPragmas(c, n2)
     result = result2
@@ -308,15 +306,7 @@ proc myImportModule(c: PContext, n: var PNode, importStmtResult: PNode): PSym =
     if belongsToStdlib(c.graph, result) and not startsWith(moduleName, stdPrefix) and
         not startsWith(moduleName, "system/") and not startsWith(moduleName, "packages/"):
       message(c.config, n.info, warnStdPrefix, realModule.name.s)
-
-    proc suggestMod(n: PNode; s: PSym) =
-      if n.kind == nkImportAs:
-        suggestMod(n[0], realModule)
-      elif n.kind == nkInfix:
-        suggestMod(n[2], s)
-      else:
-        suggestSym(c.graph, n.info, s, c.graph.usageSym, false)
-    suggestMod(n, result)
+    suggestSym(c.graph, n.info, result, c.graph.usageSym, false)
     importStmtResult.add newSymNode(result, n.info)
     #newStrNode(toFullPath(c.config, f), n.info)
   else:

compiler/injectdestructors.nim

@@ -163,8 +163,7 @@ proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
     result = false
 
 proc isLastRead(n: PNode; c: var Con; s: var Scope): bool =
-  # bug #23354; an object type could have a non-trival assignements when it is passed to a sink parameter
-  if not hasDestructor(c, n.typ) and (n.typ.kind != tyObject or isTrival(getAttachedOp(c.graph, n.typ, attachedAsgn))): return true
+  if not hasDestructor(c, n.typ): return true
 
   let m = skipConvDfa(n)
   result = (m.kind == nkSym and sfSingleUsedTemp in m.sym.flags) or
@@ -222,7 +221,7 @@ proc makePtrType(c: var Con, baseType: PType): PType =
 
 proc genOp(c: var Con; op: PSym; dest: PNode): PNode =
   var addrExp: PNode
-  if op.typ != nil and op.typ.signatureLen > 1 and op.typ.firstParamType.kind != tyVar:
+  if op.typ != nil and op.typ.len > 1 and op.typ[1].kind != tyVar:
     addrExp = dest
   else:
     addrExp = newNodeIT(nkHiddenAddr, dest.info, makePtrType(c, dest.typ))
@@ -300,7 +299,7 @@ proc genSink(c: var Con; s: var Scope; dest, ri: PNode; flags: set[MoveOrCopyFla
 proc isCriticalLink(dest: PNode): bool {.inline.} =
   #[
   Lins's idea that only "critical" links can introduce a cycle. This is
-  critical for the performance guarantees that we strive for: If you
+  critical for the performance gurantees that we strive for: If you
   traverse a data structure, no tracing will be performed at all.
   ORC is about this promise: The GC only touches the memory that the
   mutator touches too.
@@ -317,10 +316,9 @@ proc isCriticalLink(dest: PNode): bool {.inline.} =
   ]#
   result = dest.kind != nkSym
 
-proc finishCopy(c: var Con; result, dest: PNode; flags: set[MoveOrCopyFlag]; isFromSink: bool) =
-  if c.graph.config.selectedGC == gcOrc and IsExplicitSink notin flags:
-    # add cyclic flag, but not to sink calls, which IsExplicitSink generates
-    let t = dest.typ.skipTypes(tyUserTypeClasses + {tyGenericInst, tyAlias, tySink, tyDistinct})
+proc finishCopy(c: var Con; result, dest: PNode; isFromSink: bool) =
+  if c.graph.config.selectedGC == gcOrc:
+    let t = dest.typ.skipTypes({tyGenericInst, tyAlias, tySink, tyDistinct})
     if cyclicType(c.graph, t):
       result.add boolLit(c.graph, result.info, isFromSink or isCriticalLink(dest))
 
@@ -332,7 +330,7 @@ proc genMarkCyclic(c: var Con; result, dest: PNode) =
         result.add callCodegenProc(c.graph, "nimMarkCyclic", dest.info, dest)
       else:
         let xenv = genBuiltin(c.graph, c.idgen, mAccessEnv, "accessEnv", dest)
-        xenv.typ() = getSysType(c.graph, dest.info, tyPointer)
+        xenv.typ = getSysType(c.graph, dest.info, tyPointer)
         result.add callCodegenProc(c.graph, "nimMarkCyclic", dest.info, xenv)
 
 proc genCopyNoCheck(c: var Con; dest, ri: PNode; a: TTypeAttachedOp): PNode =
@@ -408,15 +406,12 @@ proc genWasMoved(c: var Con, n: PNode): PNode =
 proc genDefaultCall(t: PType; c: Con; info: TLineInfo): PNode =
   result = newNodeI(nkCall, info)
   result.add(newSymNode(createMagic(c.graph, c.idgen, "default", mDefault)))
-  result.typ() = t
+  result.typ = t
 
 proc destructiveMoveVar(n: PNode; c: var Con; s: var Scope): PNode =
   # generate: (let tmp = v; reset(v); tmp)
   if (not hasDestructor(c, n.typ)) and c.inEnsureMove == 0:
-    assert n.kind != nkSym or not hasDestructor(c, n.sym.typ) or
-          (n.typ.kind == tyPtr and n.sym.typ.kind == tyRef)
-      # bug #23505; transformed by `transf`: addr (deref ref) -> ptr
-      # we know it's really a pointer; so here we assign it directly
+    assert n.kind != nkSym or not hasDestructor(c, n.sym.typ)
     result = copyTree(n)
   else:
     result = newNodeIT(nkStmtListExpr, n.info, n.typ)
@@ -447,25 +442,24 @@ proc isCapturedVar(n: PNode): bool =
 
 proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
   result = newNodeIT(nkStmtListExpr, n.info, n.typ)
-  let nTyp = n.typ.skipTypes(tyUserTypeClasses)
-  let tmp = c.getTemp(s, nTyp, n.info)
-  if hasDestructor(c, nTyp):
-    let typ = nTyp.skipTypes({tyGenericInst, tyAlias, tySink})
+  let tmp = c.getTemp(s, n.typ, n.info)
+  if hasDestructor(c, n.typ):
+    let typ = n.typ.skipTypes({tyGenericInst, tyAlias, tySink})
     let op = getAttachedOp(c.graph, typ, attachedDup)
     if op != nil and tfHasOwned notin typ.flags:
       if sfError in op.flags:
-        c.checkForErrorPragma(nTyp, n, "=dup")
+        c.checkForErrorPragma(n.typ, n, "=dup")
       else:
         let copyOp = getAttachedOp(c.graph, typ, attachedAsgn)
         if copyOp != nil and sfError in copyOp.flags and
            sfOverridden notin op.flags:
-          c.checkForErrorPragma(nTyp, n, "=dup", inferredFromCopy = true)
+          c.checkForErrorPragma(n.typ, n, "=dup", inferredFromCopy = true)
 
       let src = p(n, c, s, normal)
       var newCall = newTreeIT(nkCall, src.info, src.typ,
             newSymNode(op),
             src)
-      c.finishCopy(newCall, n, {}, isFromSink = true)
+      c.finishCopy(newCall, n, isFromSink = true)
       result.add newTreeI(nkFastAsgn,
           src.info, tmp,
           newCall
@@ -474,9 +468,9 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
       result.add c.genWasMoved(tmp)
       var m = c.genCopy(tmp, n, {})
       m.add p(n, c, s, normal)
-      c.finishCopy(m, n, {}, isFromSink = true)
+      c.finishCopy(m, n, isFromSink = true)
       result.add m
-    if isLValue(n) and not isCapturedVar(n) and nTyp.skipTypes(abstractInst).kind != tyRef and c.inSpawn == 0:
+    if isLValue(n) and not isCapturedVar(n) and n.typ.skipTypes(abstractInst).kind != tyRef and c.inSpawn == 0:
       message(c.graph.config, n.info, hintPerformance,
         ("passing '$1' to a sink parameter introduces an implicit copy; " &
         "if possible, rearrange your program's control flow to prevent it") % $n)
@@ -485,8 +479,8 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
         ("cannot move '$1', passing '$1' to a sink parameter introduces an implicit copy") % $n)
   else:
     if c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc}:
-      assert(not containsManagedMemory(nTyp))
-    if nTyp.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
+      assert(not containsManagedMemory(n.typ))
+    if n.typ.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
       localError(c.graph.config, n.info, "cannot create an implicit openArray copy to be passed to a sink parameter")
     result.add newTree(nkAsgn, tmp, p(n, c, s, normal))
   # Since we know somebody will take over the produced copy, there is
@@ -495,14 +489,14 @@ proc passCopyToSink(n: PNode; c: var Con; s: var Scope): PNode =
 
 proc isDangerousSeq(t: PType): bool {.inline.} =
   let t = t.skipTypes(abstractInst)
-  result = t.kind == tySequence and tfHasOwned notin t.elementType.flags
+  result = t.kind == tySequence and tfHasOwned notin t[0].flags
 
 proc containsConstSeq(n: PNode): bool =
   if n.kind == nkBracket and n.len > 0 and n.typ != nil and isDangerousSeq(n.typ):
     return true
   result = false
   case n.kind
-  of nkExprEqExpr, nkExprColonExpr, nkHiddenStdConv, nkHiddenSubConv, nkCast:
+  of nkExprEqExpr, nkExprColonExpr, nkHiddenStdConv, nkHiddenSubConv:
     result = containsConstSeq(n[1])
   of nkObjConstr, nkClosure:
     for i in 1..<n.len:
@@ -600,9 +594,7 @@ template processScopeExpr(c: var Con; s: var Scope; ret: PNode, processCall: unt
   # tricky because you would have to intercept moveOrCopy at a certain point
   let tmp = c.getTemp(s.parent[], ret.typ, ret.info)
   tmp.sym.flags = tmpFlags
-  let cpy = if hasDestructor(c, ret.typ) and
-                ret.typ.kind notin {tyOpenArray, tyVarargs}:
-                # bug #23247 we don't own the data, so it's harmful to destroy it
+  let cpy = if hasDestructor(c, ret.typ):
               s.parent[].final.add c.genDestroy(tmp)
               moveOrCopy(tmp, ret, c, s, {IsDecl})
             else:
@@ -654,7 +646,7 @@ template handleNestedTempl(n, processCall: untyped, willProduceStmt = false,
       for j in 0 ..< it.len-1:
         branch[j] = copyTree(it[j])
       var ofScope = nestedScope(s, it.lastSon)
-      branch[^1] = if n.typ.isEmptyType or it[^1].typ.isEmptyType or willProduceStmt:
+      branch[^1] = if it[^1].typ.isEmptyType or willProduceStmt:
                      processScope(c, ofScope, maybeVoid(it[^1], ofScope))
                    else:
                      processScopeExpr(c, ofScope, it[^1], processCall, tmpFlags)
@@ -702,7 +694,7 @@ template handleNestedTempl(n, processCall: untyped, willProduceStmt = false,
         #Condition needs to be destroyed outside of the condition/branch scope
         branch[0] = p(it[0], c, s, normal)
 
-      branch[^1] = if n.typ.isEmptyType or it[^1].typ.isEmptyType or willProduceStmt:
+      branch[^1] = if it[^1].typ.isEmptyType or willProduceStmt:
                      processScope(c, branchScope, maybeVoid(it[^1], branchScope))
                    else:
                      processScopeExpr(c, branchScope, it[^1], processCall, tmpFlags)
@@ -762,7 +754,7 @@ proc pRaiseStmt(n: PNode, c: var Con; s: var Scope): PNode =
       let tmp = c.getTemp(s, n[0].typ, n.info)
       var m = c.genCopyNoCheck(tmp, n[0], attachedAsgn)
       m.add p(n[0], c, s, normal)
-      c.finishCopy(m, n[0], {}, isFromSink = false)
+      c.finishCopy(m, n[0], isFromSink = false)
       result = newTree(nkStmtList, c.genWasMoved(tmp), m)
       var toDisarm = n[0]
       if toDisarm.kind == nkStmtListExpr: toDisarm = toDisarm.lastSon
@@ -777,18 +769,6 @@ proc pRaiseStmt(n: PNode, c: var Con; s: var Scope): PNode =
       result.add copyNode(n[0])
   s.needsTry = true
 
-template isCustomDestructor(c: Con, t: PType): bool =
-  hasDestructor(c, t) and
-          getAttachedOp(c.graph, t, attachedDestructor) != nil and
-          sfOverridden in getAttachedOp(c.graph, t, attachedDestructor).flags
-
-proc hasCustomDestructor(c: Con, t: PType): bool =
-  result = isCustomDestructor(c, t)
-  var obj = t
-  while obj.baseClass != nil:
-    obj = skipTypes(obj.baseClass, abstractPtrs)
-    result = result or isCustomDestructor(c, obj)
-
 proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSingleUsedTemp}; inReturn = false): PNode =
   if n.kind in {nkStmtList, nkStmtListExpr, nkBlockStmt, nkBlockExpr, nkIfStmt,
                 nkIfExpr, nkCaseStmt, nkWhen, nkWhileStmt, nkParForStmt, nkTryStmt, nkPragmaBlock}:
@@ -822,17 +802,14 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
           n[1].typ.skipTypes(abstractInst-{tyOwned}).kind == tyOwned:
         # allow conversions from owned to unowned via this little hack:
         let nTyp = n[1].typ
-        n[1].typ() = n.typ
+        n[1].typ = n.typ
         result[1] = p(n[1], c, s, sinkArg)
-        result[1].typ() = nTyp
+        result[1].typ = nTyp
       else:
         result[1] = p(n[1], c, s, sinkArg)
     elif n.kind in {nkObjDownConv, nkObjUpConv}:
       result = copyTree(n)
       result[0] = p(n[0], c, s, sinkArg)
-    elif n.kind == nkCast and n.typ.skipTypes(abstractInst).kind in {tyString, tySequence}:
-      result = copyTree(n)
-      result[1] = p(n[1], c, s, sinkArg)
     elif n.typ == nil:
       # 'raise X' can be part of a 'case' expression. Deal with it here:
       result = p(n, c, s, normal)
@@ -876,14 +853,15 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       for i in 1..<n.len:
         if n[i].kind == nkExprColonExpr:
           let field = lookupFieldAgain(t, n[i][0].sym)
-          if field != nil and (sfCursor in field.flags or field.typ.kind in {tyOpenArray, tyVarargs}):
-            # don't sink fields with openarray types
+          if field != nil and sfCursor in field.flags:
             result[i][1] = p(n[i][1], c, s, normal)
           else:
             result[i][1] = p(n[i][1], c, s, m)
         else:
           result[i] = p(n[i], c, s, m)
-      if mode == normal and (isRefConstr or hasCustomDestructor(c, t)):
+      if mode == normal and (isRefConstr or (hasDestructor(c, t) and
+        getAttachedOp(c.graph, t, attachedDestructor) != nil and
+        sfOverridden in getAttachedOp(c.graph, t, attachedDestructor).flags)):
         result = ensureDestruction(result, n, c, s)
     of nkCallKinds:
       if n[0].kind == nkSym and n[0].sym.magic == mEnsureMove:
@@ -898,9 +876,8 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       elif c.inSpawn > 0:
         c.inSpawn.dec
 
-      # bug #23907; skips tyGenericInst for generic callbacks
-      let parameters = if n[0].typ != nil: n[0].typ.skipTypes(abstractInst) else: n[0].typ
-      let L = if parameters != nil: parameters.signatureLen else: 0
+      let parameters = n[0].typ
+      let L = if parameters != nil: parameters.len else: 0
 
       when false:
         var isDangerous = false
@@ -930,10 +907,7 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
         result[0] = p(n[0], c, s, normal)
       if canRaise(n[0]): s.needsTry = true
       if mode == normal:
-        if result.typ != nil and result.typ.kind notin {tyOpenArray, tyVarargs}:
-          # Returns of openarray types shouldn't be destroyed
-          # bug #19435; # bug #23247
-          result = ensureDestruction(result, n, c, s)
+        result = ensureDestruction(result, n, c, s)
     of nkDiscardStmt: # Small optimization
       result = shallowCopy(n)
       if n[0].kind != nkEmpty:
@@ -1022,9 +996,9 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
           n[1].typ.skipTypes(abstractInst-{tyOwned}).kind == tyOwned:
         # allow conversions from owned to unowned via this little hack:
         let nTyp = n[1].typ
-        n[1].typ() = n.typ
+        n[1].typ = n.typ
         result[1] = p(n[1], c, s, mode)
-        result[1].typ() = nTyp
+        result[1].typ = nTyp
       else:
         result[1] = p(n[1], c, s, mode)
 
@@ -1174,7 +1148,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
     of nkBracket:
       # array constructor
       if ri.len > 0 and isDangerousSeq(ri.typ):
@@ -1182,7 +1156,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
       else:
         result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
     of nkObjConstr, nkTupleConstr, nkClosure, nkCharLit..nkNilLit:
@@ -1192,9 +1166,9 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         # Rule 3: `=sink`(x, z); wasMoved(z)
         let snk = c.genSink(s, dest, ri, flags)
         result = newTree(nkStmtList, snk, c.genWasMoved(ri))
-      elif ri.sym.kind != skParam and
-          isAnalysableFieldAccess(ri, c.owner) and
-          isLastRead(ri, c, s) and canBeMoved(c, dest.typ):
+      elif ri.sym.kind != skParam and ri.sym.owner == c.owner and
+          isLastRead(ri, c, s) and canBeMoved(c, dest.typ) and not isCursor(ri) and
+          not ({sfGlobal, sfPure} <= ri.sym.flags):
         # Rule 3: `=sink`(x, z); wasMoved(z)
         let snk = c.genSink(s, dest, ri, flags)
         result = newTree(nkStmtList, snk, c.genWasMoved(ri))
@@ -1203,7 +1177,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
     of nkHiddenSubConv, nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv, nkCast:
       result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
     of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt:
@@ -1223,7 +1197,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result = c.genCopy(dest, ri, flags)
         dec c.inEnsureMove, isEnsureMove
         result.add p(ri, c, s, consumed)
-        c.finishCopy(result, dest, flags, isFromSink = false)
+        c.finishCopy(result, dest, isFromSink = false)
 
 when false:
   proc computeUninit(c: var Con) =

compiler/installer.ini

@@ -6,11 +6,11 @@ Name: "Nim"
 Version: "$version"
 Platforms: """
   windows: i386;amd64
-  linux: i386;hppa;ia64;alpha;amd64;powerpc64;arm;sparc;sparc64;m68k;mips;mipsel;mips64;mips64el;powerpc;powerpc64el;arm64;riscv32;riscv64;loongarch64
+  linux: i386;hppa;ia64;alpha;amd64;powerpc64;arm;sparc;sparc64;m68k;mips;mipsel;mips64;mips64el;powerpc;powerpc64el;arm64;riscv32;riscv64
   macosx: i386;amd64;powerpc64;arm64
   solaris: i386;amd64;sparc;sparc64
   freebsd: i386;amd64;powerpc64;arm;arm64;riscv64;sparc64;mips;mipsel;mips64;mips64el;powerpc;powerpc64el
-  netbsd: i386;amd64;arm64
+  netbsd: i386;amd64
   openbsd: i386;amd64;arm;arm64
   dragonfly: i386;amd64
   crossos: amd64
@@ -147,4 +147,4 @@ licenses: "bin/nim,MIT;lib/*,MIT;"
 
 [nimble]
 pkgName: "nim"
-pkgFiles: "compiler/*;doc/basicopt.txt;doc/advopt.txt;doc/nimdoc.css;doc/nimdoc.cls"
+pkgFiles: "compiler/*;doc/basicopt.txt;doc/advopt.txt;doc/nimdoc.css"

compiler/int128.nim

@@ -34,7 +34,6 @@ proc `$`*(a: Int128): string
 
 proc toInt128*[T: SomeInteger | bool](arg: T): Int128 =
   {.noSideEffect.}:
-    result = Zero
     when T is bool: result.sdata(0) = int32(arg)
     elif T is SomeUnsignedInt:
       when sizeof(arg) <= 4:
@@ -209,35 +208,30 @@ proc `==`*(a, b: Int128): bool =
   return true
 
 proc bitnot*(a: Int128): Int128 =
-  result = Zero
   result.udata[0] = not a.udata[0]
   result.udata[1] = not a.udata[1]
   result.udata[2] = not a.udata[2]
   result.udata[3] = not a.udata[3]
 
 proc bitand*(a, b: Int128): Int128 =
-  result = Zero
   result.udata[0] = a.udata[0] and b.udata[0]
   result.udata[1] = a.udata[1] and b.udata[1]
   result.udata[2] = a.udata[2] and b.udata[2]
   result.udata[3] = a.udata[3] and b.udata[3]
 
 proc bitor*(a, b: Int128): Int128 =
-  result = Zero
   result.udata[0] = a.udata[0] or b.udata[0]
   result.udata[1] = a.udata[1] or b.udata[1]
   result.udata[2] = a.udata[2] or b.udata[2]
   result.udata[3] = a.udata[3] or b.udata[3]
 
 proc bitxor*(a, b: Int128): Int128 =
-  result = Zero
   result.udata[0] = a.udata[0] xor b.udata[0]
   result.udata[1] = a.udata[1] xor b.udata[1]
   result.udata[2] = a.udata[2] xor b.udata[2]
   result.udata[3] = a.udata[3] xor b.udata[3]
 
 proc `shr`*(a: Int128, b: int): Int128 =
-  result = Zero
   let b = b and 127
   if b < 32:
     result.sdata(3) = a.sdata(3) shr b
@@ -264,7 +258,6 @@ proc `shr`*(a: Int128, b: int): Int128 =
     result.sdata(0) = a.sdata(3) shr (b and 31)
 
 proc `shl`*(a: Int128, b: int): Int128 =
-  result = Zero
   let b = b and 127
   if b < 32:
     result.udata[0] = a.udata[0] shl b
@@ -288,7 +281,6 @@ proc `shl`*(a: Int128, b: int): Int128 =
     result.udata[3] = a.udata[0] shl (b and 31)
 
 proc `+`*(a, b: Int128): Int128 =
-  result = Zero
   let tmp0 = uint64(a.udata[0]) + uint64(b.udata[0])
   result.udata[0] = cast[uint32](tmp0)
   let tmp1 = uint64(a.udata[1]) + uint64(b.udata[1]) + (tmp0 shr 32)
@@ -321,7 +313,6 @@ proc abs(a: int32): int =
   if a < 0: -a else: a
 
 proc `*`(a: Int128, b: uint32): Int128 =
-  result = Zero
   let tmp0 = uint64(a.udata[0]) * uint64(b)
   let tmp1 = uint64(a.udata[1]) * uint64(b)
   let tmp2 = uint64(a.udata[2]) * uint64(b)
@@ -344,7 +335,6 @@ proc `*=`(a: var Int128, b: int32) =
   a = a * b
 
 proc makeInt128(high, low: uint64): Int128 =
-  result = Zero
   result.udata[0] = cast[uint32](low)
   result.udata[1] = cast[uint32](low shr 32)
   result.udata[2] = cast[uint32](high)
@@ -383,8 +373,6 @@ proc fastLog2*(a: Int128): int =
 
 proc divMod*(dividend, divisor: Int128): tuple[quotient, remainder: Int128] =
   assert(divisor != Zero)
-  result = (Zero, Zero)
-
   let isNegativeA = isNegative(dividend)
   let isNegativeB = isNegative(divisor)
 
@@ -551,28 +539,24 @@ proc toInt128*(arg: float64): Int128 =
     return res
 
 proc maskUInt64*(arg: Int128): Int128 {.noinit, inline.} =
-  result = Zero
   result.udata[0] = arg.udata[0]
   result.udata[1] = arg.udata[1]
   result.udata[2] = 0
   result.udata[3] = 0
 
 proc maskUInt32*(arg: Int128): Int128 {.noinit, inline.} =
-  result = Zero
   result.udata[0] = arg.udata[0]
   result.udata[1] = 0
   result.udata[2] = 0
   result.udata[3] = 0
 
 proc maskUInt16*(arg: Int128): Int128 {.noinit, inline.} =
-  result = Zero
   result.udata[0] = arg.udata[0] and 0xffff
   result.udata[1] = 0
   result.udata[2] = 0
   result.udata[3] = 0
 
 proc maskUInt8*(arg: Int128): Int128 {.noinit, inline.} =
-  result = Zero
   result.udata[0] = arg.udata[0] and 0xff
   result.udata[1] = 0
   result.udata[2] = 0

compiler/isolation_check.nim

@@ -54,18 +54,18 @@ proc canAlias(arg, ret: PType; marker: var IntSet): bool =
   of tyObject:
     if isFinal(ret):
       result = canAliasN(arg, ret.n, marker)
-      if not result and ret.baseClass != nil:
-        result = canAlias(arg, ret.baseClass, marker)
+      if not result and ret.len > 0 and ret[0] != nil:
+        result = canAlias(arg, ret[0], marker)
     else:
       result = true
   of tyTuple:
     result = false
-    for r in ret.kids:
-      result = canAlias(arg, r, marker)
+    for i in 0..<ret.len:
+      result = canAlias(arg, ret[i], marker)
       if result: break
   of tyArray, tySequence, tyDistinct, tyGenericInst,
      tyAlias, tyInferred, tySink, tyLent, tyOwned, tyRef:
-    result = canAlias(arg, ret.skipModifier, marker)
+    result = canAlias(arg, ret.lastSon, marker)
   of tyProc:
     result = ret.callConv == ccClosure
   else:
@@ -119,16 +119,14 @@ proc containsDangerousRefAux(t: PType; marker: var IntSet): SearchResult =
   if result != NotFound: return result
   case t.kind
   of tyObject:
-    if t.baseClass != nil:
-      result = containsDangerousRefAux(t.baseClass.skipTypes(skipPtrs), marker)
+    if t[0] != nil:
+      result = containsDangerousRefAux(t[0].skipTypes(skipPtrs), marker)
     if result == NotFound: result = containsDangerousRefAux(t.n, marker)
   of tyGenericInst, tyDistinct, tyAlias, tySink:
-    result = containsDangerousRefAux(skipModifier(t), marker)
-  of tyArray, tySet, tySequence:
-    result = containsDangerousRefAux(t.elementType, marker)
-  of tyTuple:
-    for a in t.kids:
-      result = containsDangerousRefAux(a, marker)
+    result = containsDangerousRefAux(lastSon(t), marker)
+  of tyArray, tySet, tyTuple, tySequence:
+    for i in 0..<t.len:
+      result = containsDangerousRefAux(t[i], marker)
       if result == Found: return result
   else:
     discard

compiler/jsgen.nim

@@ -31,10 +31,9 @@ implements the required case distinction.
 import
   ast, trees, magicsys, options,
   nversion, msgs, idents, types,
-  ropes, wordrecg, renderer,
+  ropes, ccgutils, wordrecg, renderer,
   cgmeth, lowerings, sighashes, modulegraphs, lineinfos,
-  transf, injectdestructors, sourcemap, astmsgs, pushpoppragmas,
-  mangleutils
+  transf, injectdestructors, sourcemap, astmsgs, backendpragmas
 
 import pipelineutils
 
@@ -103,33 +102,29 @@ type
     prc: PSym
     globals, locals, body: Rope
     options: TOptions
-    optionsStack: seq[(TOptions, TNoteKinds)]
+    optionsStack: seq[TOptions]
     module: BModule
     g: PGlobals
+    generatedParamCopies: IntSet
     beforeRetNeeded: bool
     unique: int    # for temp identifier generation
     blocks: seq[TBlock]
     extraIndent: int
-    previousFileName: string  # For frameInfo inside templates.
-    # legacy: generatedParamCopies and up fields are used for jsNoLambdaLifting
-    generatedParamCopies: IntSet
     up: PProc     # up the call chain; required for closure support
+    declaredGlobals: IntSet
+    previousFileName: string  # For frameInfo inside templates.
 
 template config*(p: PProc): ConfigRef = p.module.config
 
 proc indentLine(p: PProc, r: Rope): Rope =
   var p = p
-  if jsNoLambdaLifting in p.config.legacyFeatures:
-    var ind = 0
-    while true:
-      inc ind, p.blocks.len + p.extraIndent
-      if p.up == nil or p.up.prc != p.prc.owner:
-        break
-      p = p.up
-    result = repeat(' ', ind*2) & r
-  else:
-    let ind = p.blocks.len + p.extraIndent
-    result = repeat(' ', ind*2) & r
+  var ind = 0
+  while true:
+    inc ind, p.blocks.len + p.extraIndent
+    if p.up == nil or p.up.prc != p.prc.owner:
+      break
+    p = p.up
+  result = repeat(' ', ind*2) & r
 
 template line(p: PProc, added: string) =
   p.body.add(indentLine(p, rope(added)))
@@ -180,6 +175,10 @@ proc initProcOptions(module: BModule): TOptions =
 proc newInitProc(globals: PGlobals, module: BModule): PProc =
   result = newProc(globals, module, nil, initProcOptions(module))
 
+proc declareGlobal(p: PProc; id: int; r: Rope) =
+  if p.prc != nil and not p.declaredGlobals.containsOrIncl(id):
+    p.locals.addf("global $1;$n", [r])
+
 const
   MappedToObject = {tyObject, tyArray, tyTuple, tyOpenArray,
     tySet, tyVarargs}
@@ -188,16 +187,16 @@ proc mapType(typ: PType): TJSTypeKind =
   let t = skipTypes(typ, abstractInst)
   case t.kind
   of tyVar, tyRef, tyPtr:
-    if skipTypes(t.elementType, abstractInst).kind in MappedToObject:
+    if skipTypes(t.lastSon, abstractInst).kind in MappedToObject:
       result = etyObject
     else:
       result = etyBaseIndex
   of tyPointer:
     # treat a tyPointer like a typed pointer to an array of bytes
     result = etyBaseIndex
-  of tyRange, tyDistinct, tyOrdinal, tyError, tyLent:
+  of tyRange, tyDistinct, tyOrdinal, tyProxy, tyLent:
     # tyLent is no-op as JS has pass-by-reference semantics
-    result = mapType(skipModifier t)
+    result = mapType(t[0])
   of tyInt..tyInt64, tyUInt..tyUInt64, tyEnum, tyChar: result = etyInt
   of tyBool: result = etyBool
   of tyFloat..tyFloat128: result = etyFloat
@@ -213,9 +212,9 @@ proc mapType(typ: PType): TJSTypeKind =
     result = etyNone
   of tyGenericInst, tyInferred, tyAlias, tyUserTypeClass, tyUserTypeClassInst,
      tySink, tyOwned:
-    result = mapType(typ.skipModifier)
+    result = mapType(typ.lastSon)
   of tyStatic:
-    if t.n != nil: result = mapType(skipModifier t)
+    if t.n != nil: result = mapType(lastSon t)
     else: result = etyNone
   of tyProc: result = etyProc
   of tyCstring: result = etyString
@@ -246,7 +245,7 @@ proc mangleName(m: BModule, s: PSym): Rope =
     for chr in name:
       if chr notin {'A'..'Z','a'..'z','_','$','0'..'9'}:
         return false
-  result = s.loc.snippet
+  result = s.loc.r
   if result == "":
     if s.kind == skField and s.name.s.validJsName:
       result = rope(s.name.s)
@@ -270,14 +269,10 @@ proc mangleName(m: BModule, s: PSym): Rope =
         # When hot reloading is enabled, we must ensure that the names
         # of functions and types will be preserved across rebuilds:
         result.add(idOrSig(s, m.module.name.s, m.sigConflicts, m.config))
-      elif s.kind == skParam:
-        result.add mangleParamExt(s)
-      elif s.kind in routineKinds:
-        result.add mangleProcNameExt(m.graph, s)
       else:
         result.add("_")
         result.add(rope(s.id))
-    s.loc.snippet = result
+    s.loc.r = result
 
 proc escapeJSString(s: string): string =
   result = newStringOfCap(s.len + s.len shr 2)
@@ -469,6 +464,9 @@ const # magic checked op; magic unchecked op;
     mUnaryMinusF64: ["", ""],
     mCharToStr: ["nimCharToStr", "nimCharToStr"],
     mBoolToStr: ["nimBoolToStr", "nimBoolToStr"],
+    mIntToStr: ["cstrToNimstr", "cstrToNimstr"],
+    mInt64ToStr: ["cstrToNimstr", "cstrToNimstr"],
+    mFloatToStr: ["cstrToNimstr", "cstrToNimstr"],
     mCStrToStr: ["cstrToNimstr", "cstrToNimstr"],
     mStrToStr: ["", ""]]
 
@@ -518,7 +516,7 @@ proc maybeMakeTempAssignable(p: PProc, n: PNode; x: TCompRes): tuple[a, tmp: Rop
       let (m1, tmp1) = maybeMakeTemp(p, n[0], address)
       let typ = skipTypes(n[0].typ, abstractPtrs)
       if typ.kind == tyArray:
-        first = firstOrd(p.config, typ.indexType)
+        first = firstOrd(p.config, typ[0])
       if optBoundsCheck in p.options:
         useMagic(p, "chckIndx")
         if first == 0: # save a couple chars
@@ -611,17 +609,6 @@ template unaryExpr(p: PProc, n: PNode, r: var TCompRes, magic, frmt: string) =
   r.res = frmt % [a, tmp]
   r.kind = resExpr
 
-proc genBreakState(p: PProc, n: PNode, r: var TCompRes) =
-  var a: TCompRes = default(TCompRes)
-  # mangle `:state` properly somehow
-  if n.kind == nkClosure:
-    gen(p, n[1], a)
-    r.res = "(($1).HEX3Astate < 0)" % [rdLoc(a)]
-  else:
-    gen(p, n, a)
-    r.res = "((($1.ClE_0).HEX3Astate) < 0)" % [rdLoc(a)]
-  r.kind = resExpr
-
 proc arithAux(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
   var
     x, y: TCompRes = default(TCompRes)
@@ -801,13 +788,7 @@ proc arithAux(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
   of mEqProc: applyFormat("($1 == $2)", "($1 == $2)")
   of mUnaryMinusI: applyFormat("negInt($1)", "-($1)")
   of mUnaryMinusI64: applyFormat("negInt64($1)", "-($1)")
-  of mAbsI:
-    let typ = n[1].typ.skipTypes(abstractVarRange)
-    if typ.kind == tyInt64 and optJsBigInt64 in p.config.globalOptions:
-      useMagic(p, "absInt64")
-      applyFormat("absInt64($1)", "absInt64($1)")
-    else:
-      applyFormat("absInt($1)", "Math.abs($1)")
+  of mAbsI: applyFormat("absInt($1)", "Math.abs($1)")
   of mNot: applyFormat("!($1)", "!($1)")
   of mUnaryPlusI: applyFormat("+($1)", "+($1)")
   of mBitnotI:
@@ -824,6 +805,8 @@ proc arithAux(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
   of mUnaryMinusF64: applyFormat("-($1)", "-($1)")
   of mCharToStr: applyFormat("nimCharToStr($1)", "nimCharToStr($1)")
   of mBoolToStr: applyFormat("nimBoolToStr($1)", "nimBoolToStr($1)")
+  of mIntToStr: applyFormat("cstrToNimstr(($1) + \"\")", "cstrToNimstr(($1) + \"\")")
+  of mInt64ToStr: applyFormat("cstrToNimstr(($1) + \"\")", "cstrToNimstr(($1) + \"\")")
   of mCStrToStr: applyFormat("cstrToNimstr($1)", "cstrToNimstr($1)")
   of mStrToStr, mUnown, mIsolate, mFinished: applyFormat("$1", "$1")
   else:
@@ -844,7 +827,7 @@ proc arith(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
     arithAux(p, n, r, op)
   of mModI:
     arithAux(p, n, r, op)
-  of mCharToStr, mBoolToStr, mCStrToStr, mStrToStr, mEnumToStr:
+  of mCharToStr, mBoolToStr, mIntToStr, mInt64ToStr, mCStrToStr, mStrToStr, mEnumToStr:
     arithAux(p, n, r, op)
   of mEqRef:
     if mapType(n[1].typ) != etyBaseIndex:
@@ -854,11 +837,6 @@ proc arith(p: PProc, n: PNode, r: var TCompRes, op: TMagic) =
       gen(p, n[1], x)
       gen(p, n[2], y)
       r.res = "($# == $# && $# == $#)" % [x.address, y.address, x.res, y.res]
-  of mEqProc:
-    if skipTypes(n[1].typ, abstractInst).callConv == ccClosure:
-      binaryExpr(p, n, r, "cmpClosures", "cmpClosures($1, $2)")
-    else:
-      arithAux(p, n, r, op)
   else:
     arithAux(p, n, r, op)
   r.kind = resExpr
@@ -948,7 +926,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
     p.body.add("++excHandler;\L")
   var tmpFramePtr = rope"F"
   lineF(p, "try {$n", [])
-  var a: TCompRes = default(TCompRes)
+  var a: TCompRes
   gen(p, n[0], a)
   moveInto(p, a, r)
   var generalCatchBranchExists = false
@@ -992,7 +970,7 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
         # if isJsObject(throwObj.typ):
         if isImportedException(throwObj.typ, p.config):
           orExpr.addf("lastJSError instanceof $1",
-            [throwObj.typ.sym.loc.snippet])
+            [throwObj.typ.sym.loc.r])
         else:
           orExpr.addf("isObj(lastJSError.m_type, $1)",
                [genTypeInfo(p, throwObj.typ)])
@@ -1002,8 +980,8 @@ proc genTry(p: PProc, n: PNode, r: var TCompRes) =
       # If some branch requires a local alias introduce it here. This is needed
       # since JS cannot do ``catch x as y``.
       if excAlias != nil:
-        excAlias.sym.loc.snippet = mangleName(p.module, excAlias.sym)
-        lineF(p, "var $1 = lastJSError;$n", excAlias.sym.loc.snippet)
+        excAlias.sym.loc.r = mangleName(p.module, excAlias.sym)
+        lineF(p, "var $1 = lastJSError;$n", excAlias.sym.loc.r)
       gen(p, n[i][^1], a)
       moveInto(p, a, r)
       lineF(p, "}$n", [])
@@ -1041,7 +1019,7 @@ proc genCaseJS(p: PProc, n: PNode, r: var TCompRes) =
     a, b, cond, stmt: TCompRes = default(TCompRes)
   genLineDir(p, n)
   gen(p, n[0], cond)
-  let typeKind = skipTypes(n[0].typ, abstractVar+{tyRange}).kind
+  let typeKind = skipTypes(n[0].typ, abstractVar).kind
   var transferRange = false
   let anyString = typeKind in {tyString, tyCstring}
   case typeKind
@@ -1109,19 +1087,14 @@ proc genCaseJS(p: PProc, n: PNode, r: var TCompRes) =
           lineF(p, "break;$n", [])
     of nkElse:
       if transferRange:
-        if n.len == 2: # a dangling else for a case statement
-          transferRange = false
-          lineF(p, "switch ($1) {$n", [cond.rdLoc])
-          lineF(p, "default: $n", [])
-        else:
-          lineF(p, "else{$n", [])
+         lineF(p, "else{$n", [])
       else:
         lineF(p, "default: $n", [])
       p.nested:
         gen(p, it[0], stmt)
         moveInto(p, stmt, r)
         if transferRange:
-          lineF(p, "}$n", [])
+           lineF(p, "}$n", [])
         else:
           lineF(p, "break;$n", [])
     else: internalError(p.config, it.info, "jsgen.genCaseStmt")
@@ -1163,14 +1136,10 @@ proc genBreakStmt(p: PProc, n: PNode) =
   p.blocks[idx].id = abs(p.blocks[idx].id) # label is used
   lineF(p, "break Label$1;$n", [rope(p.blocks[idx].id)])
 
-proc genAsmOrEmitStmt(p: PProc, n: PNode; isAsmStmt = false) =
+proc genAsmOrEmitStmt(p: PProc, n: PNode) =
   genLineDir(p, n)
   p.body.add p.indentLine("")
-  let offset =
-    if isAsmStmt: 1 # first son is pragmas
-    else: 0
-
-  for i in offset..<n.len:
+  for i in 0..<n.len:
     let it = n[i]
     case it.kind
     of nkStrLit..nkTripleStrLit:
@@ -1225,17 +1194,8 @@ proc genIf(p: PProc, n: PNode, r: var TCompRes) =
     lineF(p, "}$n", [])
   line(p, repeat('}', toClose) & "\L")
 
-proc generateHeader(p: PProc, prc: PSym): Rope =
+proc generateHeader(p: PProc, typ: PType): Rope =
   result = ""
-  let typ = prc.typ
-  if jsNoLambdaLifting notin p.config.legacyFeatures:
-    if typ.callConv == ccClosure:
-      # we treat Env as the `this` parameter of the function
-      # to keep it simple
-      let env = prc.ast[paramsPos].lastSon
-      assert env.kind == nkSym, "env is missing"
-      env.sym.loc.snippet = "this"
-
   for i in 1..<typ.n.len:
     assert(typ.n[i].kind == nkSym)
     var param = typ.n[i].sym
@@ -1268,10 +1228,9 @@ const
 
 proc needsNoCopy(p: PProc; y: PNode): bool =
   return y.kind in nodeKindsNeedNoCopy or
-        ((mapType(y.typ) != etyBaseIndex or
-          (jsNoLambdaLifting in p.config.legacyFeatures and y.kind == nkSym and y.sym.kind == skParam)) and
+        ((mapType(y.typ) != etyBaseIndex or (y.kind == nkSym and y.sym.kind == skParam)) and
           (skipTypes(y.typ, abstractInst).kind in
-            {tyRef, tyPtr, tyLent, tyVar, tyCstring, tyProc, tyOwned, tyOpenArray} + IntegralTypes))
+            {tyRef, tyPtr, tyLent, tyVar, tyCstring, tyProc, tyOwned} + IntegralTypes))
 
 proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
   var a, b: TCompRes = default(TCompRes)
@@ -1298,7 +1257,7 @@ proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
       lineF(p, "$1 = nimCopy(null, $2, $3);$n",
                [a.rdLoc, b.res, genTypeInfo(p, y.typ)])
   of etyObject:
-    if x.typ.kind in {tyVar, tyLent, tyOpenArray, tyVarargs} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
+    if x.typ.kind in {tyVar, tyLent} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
       lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
     else:
       useMagic(p, "nimCopy")
@@ -1353,10 +1312,19 @@ proc genFastAsgn(p: PProc, n: PNode) =
   genAsgnAux(p, n[0], n[1], noCopyNeeded=noCopy)
 
 proc genSwap(p: PProc, n: PNode) =
-  let stmtList = lowerSwap(p.module.graph, n, p.module.idgen, if p.prc != nil: p.prc else: p.module.module)
-  assert stmtList.kind == nkStmtList
-  for i in 0..<stmtList.len:
-    genStmt(p, stmtList[i])
+  var a, b: TCompRes = default(TCompRes)
+  gen(p, n[1], a)
+  gen(p, n[2], b)
+  var tmp = p.getTemp(false)
+  if mapType(p, skipTypes(n[1].typ, abstractVar)) == etyBaseIndex:
+    let tmp2 = p.getTemp(false)
+    if a.typ != etyBaseIndex or b.typ != etyBaseIndex:
+      internalError(p.config, n.info, "genSwap")
+    lineF(p, "var $1 = $2; $2 = $3; $3 = $1;$n",
+             [tmp, a.address, b.address])
+    tmp = tmp2
+  lineF(p, "var $1 = $2; $2 = $3; $3 = $1;",
+           [tmp, a.res, b.res])
 
 proc getFieldPosition(p: PProc; f: PNode): int =
   case f.kind
@@ -1376,8 +1344,8 @@ proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
   else:
     if b[1].kind != nkSym: internalError(p.config, b[1].info, "genFieldAddr")
     var f = b[1].sym
-    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
-    r.res = makeJSString($f.loc.snippet)
+    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
+    r.res = makeJSString($f.loc.r)
   internalAssert p.config, a.typ != etyBaseIndex
   r.address = a.res
   r.kind = resExpr
@@ -1404,8 +1372,8 @@ proc genFieldAccess(p: PProc, n: PNode, r: var TCompRes) =
   else:
     if n[1].kind != nkSym: internalError(p.config, n[1].info, "genFieldAccess")
     var f = n[1].sym
-    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
-    r.res = "$1.$2" % [r.res, f.loc.snippet]
+    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
+    r.res = "$1.$2" % [r.res, f.loc.r]
     mkTemp(1)
   r.kind = resExpr
 
@@ -1425,11 +1393,11 @@ proc genCheckedFieldOp(p: PProc, n: PNode, addrTyp: PType, r: var TCompRes) =
   # Field symbol
   var field = accessExpr[1].sym
   internalAssert p.config, field.kind == skField
-  if field.loc.snippet == "": field.loc.snippet = mangleName(p.module, field)
+  if field.loc.r == "": field.loc.r = mangleName(p.module, field)
   # Discriminant symbol
   let disc = checkExpr[2].sym
   internalAssert p.config, disc.kind == skField
-  if disc.loc.snippet == "": disc.loc.snippet = mangleName(p.module, disc)
+  if disc.loc.r == "": disc.loc.r = mangleName(p.module, disc)
 
   var setx: TCompRes = default(TCompRes)
   gen(p, checkExpr[1], setx)
@@ -1446,16 +1414,16 @@ proc genCheckedFieldOp(p: PProc, n: PNode, addrTyp: PType, r: var TCompRes) =
   useMagic(p, "reprDiscriminant") # no need to offset by firstOrd unlike for cgen
   let msg = genFieldDefect(p.config, field.name.s, disc)
   lineF(p, "if ($1[$2.$3]$4undefined) { raiseFieldError2(makeNimstrLit($5), reprDiscriminant($2.$3, $6)); }$n",
-    setx.res, tmp, disc.loc.snippet, if negCheck: "!==" else: "===",
+    setx.res, tmp, disc.loc.r, if negCheck: "!==" else: "===",
     makeJSString(msg), genTypeInfo(p, disc.typ))
 
   if addrTyp != nil and mapType(p, addrTyp) == etyBaseIndex:
     r.typ = etyBaseIndex
-    r.res = makeJSString($field.loc.snippet)
+    r.res = makeJSString($field.loc.r)
     r.address = tmp
   else:
     r.typ = etyNone
-    r.res = "$1.$2" % [tmp, field.loc.snippet]
+    r.res = "$1.$2" % [tmp, field.loc.r]
   r.kind = resExpr
 
 proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
@@ -1471,7 +1439,7 @@ proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
   r.address = x
   var typ = skipTypes(m[0].typ, abstractPtrs)
   if typ.kind == tyArray:
-    first = firstOrd(p.config, typ.indexType)
+    first = firstOrd(p.config, typ[0])
   if optBoundsCheck in p.options:
     useMagic(p, "chckIndx")
     if first == 0: # save a couple chars
@@ -1486,8 +1454,8 @@ proc genArrayAddr(p: PProc, n: PNode, r: var TCompRes) =
   r.kind = resExpr
 
 proc genArrayAccess(p: PProc, n: PNode, r: var TCompRes) =
-  var ty = skipTypes(n[0].typ, abstractVarRange+tyUserTypeClasses)
-  if ty.kind in {tyRef, tyPtr, tyLent, tyOwned}: ty = skipTypes(ty.elementType, abstractVarRange)
+  var ty = skipTypes(n[0].typ, abstractVarRange)
+  if ty.kind in {tyRef, tyPtr, tyLent, tyOwned}: ty = skipTypes(ty.lastSon, abstractVarRange)
   case ty.kind
   of tyArray, tyOpenArray, tySequence, tyString, tyCstring, tyVarargs:
     genArrayAddr(p, n, r)
@@ -1522,10 +1490,10 @@ template isIndirect(x: PSym): bool =
 
 proc genSymAddr(p: PProc, n: PNode, typ: PType, r: var TCompRes) =
   let s = n.sym
-  if s.loc.snippet == "": internalError(p.config, n.info, "genAddr: 3")
+  if s.loc.r == "": internalError(p.config, n.info, "genAddr: 3")
   case s.kind
   of skParam:
-    r.res = s.loc.snippet
+    r.res = s.loc.r
     r.address = ""
     r.typ = etyNone
   of skVar, skLet, skResult:
@@ -1539,15 +1507,15 @@ proc genSymAddr(p: PProc, n: PNode, typ: PType, r: var TCompRes) =
       # make addr() a no-op:
       r.typ = etyNone
       if isIndirect(s):
-        r.res = s.loc.snippet & "[0]"
+        r.res = s.loc.r & "[0]"
       else:
-        r.res = s.loc.snippet
+        r.res = s.loc.r
       r.address = ""
     elif {sfGlobal, sfAddrTaken} * s.flags != {} or jsType == etyBaseIndex:
       # for ease of code generation, we do not distinguish between
       # sfAddrTaken and sfGlobal.
       r.typ = etyBaseIndex
-      r.address = s.loc.snippet
+      r.address = s.loc.r
       r.res = rope("0")
     else:
       # 'var openArray' for instance produces an 'addr' but this is harmless:
@@ -1574,7 +1542,7 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
       if ty.kind in MappedToObject:
         gen(p, n[0], r)
       else:
-        let kindOfIndexedExpr = skipTypes(n[0][0].typ, abstractVarRange+tyUserTypeClasses).kind
+        let kindOfIndexedExpr = skipTypes(n[0][0].typ, abstractVarRange).kind
         case kindOfIndexedExpr
         of tyArray, tyOpenArray, tySequence, tyString, tyCstring, tyVarargs:
           genArrayAddr(p, n[0], r)
@@ -1585,8 +1553,15 @@ proc genAddr(p: PProc, n: PNode, r: var TCompRes) =
         else: internalError(p.config, n[0].info, "expr(nkBracketExpr, " & $kindOfIndexedExpr & ')')
     of nkObjDownConv:
       gen(p, n[0], r)
-    of nkHiddenDeref, nkDerefExpr:
+    of nkHiddenDeref:
       gen(p, n[0], r)
+    of nkDerefExpr:
+      var x = n[0]
+      if n.kind == nkHiddenAddr:
+        x = n[0][0]
+        if n.typ.skipTypes(abstractVar).kind != tyOpenArray:
+          x.typ = n.typ
+      gen(p, x, r)
     of nkHiddenAddr:
       gen(p, n[0], r)
     of nkConv:
@@ -1613,15 +1588,12 @@ proc attachProc(p: PProc; s: PSym) =
 
 proc genProcForSymIfNeeded(p: PProc, s: PSym) =
   if not p.g.generatedSyms.containsOrIncl(s.id):
-    if jsNoLambdaLifting in p.config.legacyFeatures:
-      let newp = genProc(p, s)
-      var owner = p
-      while owner != nil and owner.prc != s.owner:
-        owner = owner.up
-      if owner != nil: owner.locals.add(newp)
-      else: attachProc(p, newp, s)
-    else:
-      attachProc(p, s)
+    let newp = genProc(p, s)
+    var owner = p
+    while owner != nil and owner.prc != s.owner:
+      owner = owner.up
+    if owner != nil: owner.locals.add(newp)
+    else: attachProc(p, newp, s)
 
 proc genCopyForParamIfNeeded(p: PProc, n: PNode) =
   let s = n.sym
@@ -1633,7 +1605,7 @@ proc genCopyForParamIfNeeded(p: PProc, n: PNode) =
       internalError(p.config, n.info, "couldn't find the owner proc of the closed over param: " & s.name.s)
     if owner.prc == s.owner:
       if not owner.generatedParamCopies.containsOrIncl(s.id):
-        let copy = "$1 = nimCopy(null, $1, $2);$n" % [s.loc.snippet, genTypeInfo(p, s.typ)]
+        let copy = "$1 = nimCopy(null, $1, $2);$n" % [s.loc.r, genTypeInfo(p, s.typ)]
         owner.locals.add(owner.indentLine(copy))
       return
     owner = owner.up
@@ -1644,40 +1616,40 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
   var s = n.sym
   case s.kind
   of skVar, skLet, skParam, skTemp, skResult, skForVar:
-    if s.loc.snippet == "":
+    if s.loc.r == "":
       internalError(p.config, n.info, "symbol has no generated name: " & s.name.s)
     if sfCompileTime in s.flags:
       genVarInit(p, s, if s.astdef != nil: s.astdef else: newNodeI(nkEmpty, s.info))
-    if jsNoLambdaLifting in p.config.legacyFeatures and s.kind == skParam:
+    if s.kind == skParam:
       genCopyForParamIfNeeded(p, n)
     let k = mapType(p, s.typ)
     if k == etyBaseIndex:
       r.typ = etyBaseIndex
       if {sfAddrTaken, sfGlobal} * s.flags != {}:
         if isIndirect(s):
-          r.address = "$1[0][0]" % [s.loc.snippet]
-          r.res = "$1[0][1]" % [s.loc.snippet]
+          r.address = "$1[0][0]" % [s.loc.r]
+          r.res = "$1[0][1]" % [s.loc.r]
         else:
-          r.address = "$1[0]" % [s.loc.snippet]
-          r.res = "$1[1]" % [s.loc.snippet]
+          r.address = "$1[0]" % [s.loc.r]
+          r.res = "$1[1]" % [s.loc.r]
       else:
-        r.address = s.loc.snippet
-        r.res = s.loc.snippet & "_Idx"
+        r.address = s.loc.r
+        r.res = s.loc.r & "_Idx"
     elif isIndirect(s):
-      r.res = "$1[0]" % [s.loc.snippet]
+      r.res = "$1[0]" % [s.loc.r]
     else:
-      r.res = s.loc.snippet
+      r.res = s.loc.r
   of skConst:
     genConstant(p, s)
-    if s.loc.snippet == "":
+    if s.loc.r == "":
       internalError(p.config, n.info, "symbol has no generated name: " & s.name.s)
-    r.res = s.loc.snippet
-  of skProc, skFunc, skConverter, skMethod, skIterator:
+    r.res = s.loc.r
+  of skProc, skFunc, skConverter, skMethod:
     if sfCompileTime in s.flags:
       localError(p.config, n.info, "request to generate code for .compileTime proc: " &
           s.name.s)
     discard mangleName(p.module, s)
-    r.res = s.loc.snippet
+    r.res = s.loc.r
     if lfNoDecl in s.loc.flags or s.magic notin generatedMagics or
        {sfImportc, sfInfixCall} * s.flags != {}:
       discard
@@ -1689,13 +1661,13 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
     else:
       genProcForSymIfNeeded(p, s)
   else:
-    if s.loc.snippet == "":
+    if s.loc.r == "":
       internalError(p.config, n.info, "symbol has no generated name: " & s.name.s)
     if mapType(p, s.typ) == etyBaseIndex:
-      r.address = s.loc.snippet
-      r.res = s.loc.snippet & "_Idx"
+      r.address = s.loc.r
+      r.res = s.loc.r & "_Idx"
     else:
-      r.res = s.loc.snippet
+      r.res = s.loc.r
   r.kind = resVal
 
 proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
@@ -1837,9 +1809,9 @@ proc genPatternCall(p: PProc; n: PNode; pat: string; typ: PType;
 proc genInfixCall(p: PProc, n: PNode, r: var TCompRes) =
   # don't call '$' here for efficiency:
   let f = n[0].sym
-  if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
+  if f.loc.r == "": f.loc.r = mangleName(p.module, f)
   if sfInfixCall in f.flags:
-    let pat = $n[0].sym.loc.snippet
+    let pat = $n[0].sym.loc.r
     internalAssert p.config, pat.len > 0
     if pat.contains({'#', '(', '@'}):
       var typ = skipTypes(n[0].typ, abstractInst)
@@ -1917,7 +1889,7 @@ proc createObjInitList(p: PProc, typ: PType, excludedFieldIDs: IntSet, output: v
   while t != nil:
     t = t.skipTypes(skipPtrs)
     createRecordVarAux(p, t.n, excludedFieldIDs, output)
-    t = t.baseClass
+    t = t[0]
 
 proc arrayTypeForElemType(conf: ConfigRef; typ: PType): string =
   let typ = typ.skipTypes(abstractRange)
@@ -1954,7 +1926,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
   of tyInt8..tyInt32, tyUInt8..tyUInt32, tyEnum, tyChar:
     result = putToSeq("0", indirect)
   of tyInt, tyUInt:
-    if $t.sym.loc.snippet == "bigint":
+    if $t.sym.loc.r == "bigint":
       result = putToSeq("0n", indirect)
     else:
       result = putToSeq("0", indirect)
@@ -1966,7 +1938,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
   of tyFloat..tyFloat128:
     result = putToSeq("0.0", indirect)
   of tyRange, tyGenericInst, tyAlias, tySink, tyOwned, tyLent:
-    result = createVar(p, skipModifier(typ), indirect)
+    result = createVar(p, lastSon(typ), indirect)
   of tySet:
     result = putToSeq("{}", indirect)
   of tyBool:
@@ -2014,11 +1986,11 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
       result = putToSeq("null", indirect)
   of tySequence, tyString:
     result = putToSeq("[]", indirect)
-  of tyCstring, tyProc, tyOpenArray:
+  of tyCstring, tyProc:
     result = putToSeq("null", indirect)
   of tyStatic:
     if t.n != nil:
-      result = createVar(p, skipModifier t, indirect)
+      result = createVar(p, lastSon t, indirect)
     else:
       internalError(p.config, "createVar: " & $t.kind)
       result = ""
@@ -2066,7 +2038,7 @@ proc genVarInit(p: PProc, v: PSym, n: PNode) =
     gen(p, n, a)
     case mapType(p, v.typ)
     of etyObject, etySeq:
-      if v.typ.kind in {tyOpenArray, tyVarargs} or needsNoCopy(p, n):
+      if needsNoCopy(p, n):
         s = a.res
       else:
         useMagic(p, "nimCopy")
@@ -2076,44 +2048,33 @@ proc genVarInit(p: PProc, v: PSym, n: PNode) =
       if a.typ == etyBaseIndex:
         if targetBaseIndex:
           line(p, runtimeFormat(varCode & " = $3, $2_Idx = $4;$n",
-                   [returnType, v.loc.snippet, a.address, a.res]))
+                   [returnType, v.loc.r, a.address, a.res]))
         else:
           if isIndirect(v):
             line(p, runtimeFormat(varCode & " = [[$3, $4]];$n",
-                     [returnType, v.loc.snippet, a.address, a.res]))
+                     [returnType, v.loc.r, a.address, a.res]))
           else:
             line(p, runtimeFormat(varCode & " = [$3, $4];$n",
-                     [returnType, v.loc.snippet, a.address, a.res]))
+                     [returnType, v.loc.r, a.address, a.res]))
       else:
         if targetBaseIndex:
           let tmp = p.getTemp
           lineF(p, "var $1 = $2, $3 = $1[0], $3_Idx = $1[1];$n",
-                   [tmp, a.res, v.loc.snippet])
+                   [tmp, a.res, v.loc.r])
         else:
-          line(p, runtimeFormat(varCode & " = $3;$n", [returnType, v.loc.snippet, a.res]))
+          line(p, runtimeFormat(varCode & " = $3;$n", [returnType, v.loc.r, a.res]))
       return
     else:
       s = a.res
     if isIndirect(v):
-      line(p, runtimeFormat(varCode & " = [$3];$n", [returnType, v.loc.snippet, s]))
+      line(p, runtimeFormat(varCode & " = [$3];$n", [returnType, v.loc.r, s]))
     else:
-      line(p, runtimeFormat(varCode & " = $3;$n", [returnType, v.loc.snippet, s]))
+      line(p, runtimeFormat(varCode & " = $3;$n", [returnType, v.loc.r, s]))
 
   if useReloadingGuard or useGlobalPragmas:
     dec p.extraIndent
     lineF(p, "}$n")
 
-proc genClosureVar(p: PProc, n: PNode) =
-  # assert n[2].kind != nkEmpty
-  # TODO: fixme transform `var env.x` into `var env.x = default()` after
-  # the order of transf and lambdalifting is fixed
-  if n[2].kind != nkEmpty:
-    genAsgnAux(p, n[0], n[2], false)
-  else:
-    var a: TCompRes = default(TCompRes)
-    gen(p, n[0], a)
-    line(p, runtimeFormat("$1 = $2;$n", [rdLoc(a), createVar(p, n[0].typ, false)]))
-
 proc genVarStmt(p: PProc, n: PNode) =
   for i in 0..<n.len:
     var a = n[i]
@@ -2123,17 +2084,15 @@ proc genVarStmt(p: PProc, n: PNode) =
         genStmt(p, unpacked)
       else:
         assert(a.kind == nkIdentDefs)
-        if a[0].kind == nkSym:
-          var v = a[0].sym
-          if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
-            genLineDir(p, a)
-            if sfCompileTime notin v.flags:
-              genVarInit(p, v, a[2])
-            else:
-              # lazy emit, done when it's actually used.
-              if v.ast == nil: v.ast = a[2]
-        else: # closure
-          genClosureVar(p, a)
+        assert(a[0].kind == nkSym)
+        var v = a[0].sym
+        if lfNoDecl notin v.loc.flags and sfImportc notin v.flags:
+          genLineDir(p, a)
+          if sfCompileTime notin v.flags:
+            genVarInit(p, v, a[2])
+          else:
+            # lazy emit, done when it's actually used.
+            if v.ast == nil: v.ast = a[2]
 
 proc genConstant(p: PProc, c: PSym) =
   if lfNoDecl notin c.loc.flags and not p.g.generatedSyms.containsOrIncl(c.id):
@@ -2180,20 +2139,20 @@ proc genConStrStr(p: PProc, n: PNode, r: var TCompRes) =
   if skipTypes(n[1].typ, abstractVarRange).kind == tyChar:
     r.res.add("[$1].concat(" % [a.res])
   else:
-    r.res.add("($1).concat(" % [a.res])
+    r.res.add("($1 || []).concat(" % [a.res])
 
   for i in 2..<n.len - 1:
     gen(p, n[i], a)
     if skipTypes(n[i].typ, abstractVarRange).kind == tyChar:
       r.res.add("[$1]," % [a.res])
     else:
-      r.res.add("$1," % [a.res])
+      r.res.add("$1 || []," % [a.res])
 
   gen(p, n[^1], a)
   if skipTypes(n[^1].typ, abstractVarRange).kind == tyChar:
     r.res.add("[$1])" % [a.res])
   else:
-    r.res.add("$1)" % [a.res])
+    r.res.add("$1 || [])" % [a.res])
 
 proc genReprAux(p: PProc, n: PNode, r: var TCompRes, magic: string, typ: Rope = "") =
   useMagic(p, magic)
@@ -2260,17 +2219,16 @@ proc genDefault(p: PProc, n: PNode; r: var TCompRes) =
   r.res = createVar(p, n.typ, indirect = false)
   r.kind = resExpr
 
-proc genWasMoved(p: PProc, n: PNode) =
-  # TODO: it should be done by nir
+proc genReset(p: PProc, n: PNode) =
   var x: TCompRes = default(TCompRes)
+  useMagic(p, "genericReset")
   gen(p, n[1], x)
   if x.typ == etyBaseIndex:
     lineF(p, "$1 = null, $2 = 0;$n", [x.address, x.res])
   else:
-    var y: TCompRes = default(TCompRes)
-    genDefault(p, n[1], y)
-    let (a, _) = maybeMakeTempAssignable(p, n[1], x)
-    lineF(p, "$1 = $2;$n", [a, y.rdLoc])
+    let (a, tmp) = maybeMakeTempAssignable(p, n[1], x)
+    lineF(p, "$1 = genericReset($3, $2);$n", [a,
+                  genTypeInfo(p, n[1].typ), tmp])
 
 proc genMove(p: PProc; n: PNode; r: var TCompRes) =
   var a: TCompRes = default(TCompRes)
@@ -2278,7 +2236,7 @@ proc genMove(p: PProc; n: PNode; r: var TCompRes) =
   r.res = p.getTemp()
   gen(p, n[1], a)
   lineF(p, "$1 = $2;$n", [r.rdLoc, a.rdLoc])
-  genWasMoved(p, n)
+  genReset(p, n)
   #lineF(p, "$1 = $2;$n", [dest.rdLoc, src.rdLoc])
 
 proc genDup(p: PProc; n: PNode; r: var TCompRes) =
@@ -2451,7 +2409,6 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
   of mMulSet: binaryExpr(p, n, r, "SetMul", "SetMul($1, $2)")
   of mPlusSet: binaryExpr(p, n, r, "SetPlus", "SetPlus($1, $2)")
   of mMinusSet: binaryExpr(p, n, r, "SetMinus", "SetMinus($1, $2)")
-  of mXorSet: binaryExpr(p, n, r, "SetXor", "SetXor($1, $2)")
   of mIncl: binaryExpr(p, n, r, "", "$1[$2] = true")
   of mExcl: binaryExpr(p, n, r, "", "delete $1[$2]")
   of mInSet:
@@ -2460,7 +2417,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
   of mNewSeqOfCap: unaryExpr(p, n, r, "", "[]")
   of mOf: genOf(p, n, r)
   of mDefault, mZeroDefault: genDefault(p, n, r)
-  of mWasMoved: genWasMoved(p, n)
+  of mReset, mWasMoved: genReset(p, n)
   of mEcho: genEcho(p, n, r)
   of mNLen..mNError, mSlurp, mStaticExec:
     localError(p.config, n.info, errXMustBeCompileTime % n[0].sym.name.s)
@@ -2573,17 +2530,17 @@ proc genObjConstr(p: PProc, n: PNode, r: var TCompRes) =
     let val = it[1]
     gen(p, val, a)
     var f = it[0].sym
-    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
+    if f.loc.r == "": f.loc.r = mangleName(p.module, f)
     fieldIDs.incl(lookupFieldAgain(n.typ.skipTypes({tyDistinct}), f).id)
 
     let typ = val.typ.skipTypes(abstractInst)
     if a.typ == etyBaseIndex:
-      initList.addf("$#: [$#, $#]", [f.loc.snippet, a.address, a.res])
+      initList.addf("$#: [$#, $#]", [f.loc.r, a.address, a.res])
     else:
       if not needsNoCopy(p, val):
         useMagic(p, "nimCopy")
         a.res = "nimCopy(null, $1, $2)" % [a.rdLoc, genTypeInfo(p, typ)]
-      initList.addf("$#: $#", [f.loc.snippet, a.res])
+      initList.addf("$#: $#", [f.loc.r, a.res])
   let t = skipTypes(n.typ, abstractInst + skipPtrs)
   createObjInitList(p, t, fieldIDs, initList)
   r.res = ("{$1}") % [initList]
@@ -2642,13 +2599,7 @@ proc genRangeChck(p: PProc, n: PNode, r: var TCompRes, magic: string) =
   let src = skipTypes(n[0].typ, abstractVarRange)
   let dest = skipTypes(n.typ, abstractVarRange)
   if optRangeCheck notin p.options:
-    if optJsBigInt64 in p.config.globalOptions and
-          dest.kind in {tyUInt..tyUInt32, tyInt..tyInt32} and
-          src.kind in {tyInt64, tyUInt64}:
-      # conversions to Number are kept
-      r.res = "Number($1)" % [r.res]
-    else:
-      discard
+    return
   elif dest.kind in {tyUInt..tyUInt64} and checkUnsignedConversions notin p.config.legacyFeatures:
     if src.kind in {tyInt64, tyUInt64} and optJsBigInt64 in p.config.globalOptions:
       r.res = "BigInt.asUintN($1, $2)" % [$(dest.size * 8), r.res]
@@ -2747,8 +2698,8 @@ proc genProc(oldProc: PProc, prc: PSym): Rope =
   var returnStmt: Rope = ""
   var resultAsgn: Rope = ""
   var name = mangleName(p.module, prc)
-  let header = generateHeader(p, prc)
-  if prc.typ.returnType != nil and sfPure notin prc.flags:
+  let header = generateHeader(p, prc.typ)
+  if prc.typ[0] != nil and sfPure notin prc.flags:
     resultSym = prc.ast[resultPos].sym
     let mname = mangleName(p.module, resultSym)
     # otherwise uses "fat pointers"
@@ -2829,9 +2780,9 @@ proc genPragma(p: PProc, n: PNode) =
     case whichPragma(it)
     of wEmit: genAsmOrEmitStmt(p, it[1])
     of wPush:
-      processPushBackendOption(p.config, p.optionsStack, p.options, n, i+1)
+      processPushBackendOption(p.optionsStack, p.options, n, i+1)
     of wPop:
-      processPopBackendOption(p.config, p.optionsStack, p.options)
+      processPopBackendOption(p.optionsStack, p.options)
     else: discard
 
 proc genCast(p: PProc, n: PNode, r: var TCompRes) =
@@ -2966,18 +2917,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
       genInfixCall(p, n, r)
     else:
       genCall(p, n, r)
-  of nkClosure:
-    if jsNoLambdaLifting in p.config.legacyFeatures:
-      gen(p, n[0], r)
-    else:
-      let tmp = getTemp(p)
-      var a: TCompRes = default(TCompRes)
-      var b: TCompRes = default(TCompRes)
-      gen(p, n[0], a)
-      gen(p, n[1], b)
-      lineF(p, "$1 = $2.bind($3); $1.ClP_0 = $2; $1.ClE_0 = $3;$n", [tmp, a.rdLoc, b.rdLoc])
-      r.res = tmp
-      r.kind = resVal
+  of nkClosure: gen(p, n[0], r)
   of nkCurly: genSetConstr(p, n, r)
   of nkBracket: genArrayConstr(p, n, r)
   of nkPar, nkTupleConstr: genTupleConstr(p, n, r)
@@ -3008,7 +2948,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
   of nkLambdaKinds:
     let s = n[namePos].sym
     discard mangleName(p.module, s)
-    r.res = s.loc.snippet
+    r.res = s.loc.r
     if lfNoDecl in s.loc.flags or s.magic notin generatedMagics: discard
     elif not p.g.generatedSyms.containsOrIncl(s.id):
       p.locals.add(genProc(p, s))
@@ -3040,16 +2980,17 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
     if n[0].kind != nkEmpty:
       genLineDir(p, n)
       gen(p, n[0], r)
-      r.res = "(" & r.res & ")"
-  of nkAsmStmt:
-    warningDeprecated(p.config, n.info, "'asm' for the JS target is deprecated, use the 'emit' pragma")
-    genAsmOrEmitStmt(p, n, true)
+      r.res = "var _ = " & r.res
+  of nkAsmStmt: genAsmOrEmitStmt(p, n)
   of nkTryStmt, nkHiddenTryStmt: genTry(p, n, r)
   of nkRaiseStmt: genRaiseStmt(p, n)
   of nkTypeSection, nkCommentStmt, nkIncludeStmt,
      nkImportStmt, nkImportExceptStmt, nkExportStmt, nkExportExceptStmt,
-     nkFromStmt, nkTemplateDef, nkMacroDef, nkIteratorDef, nkStaticStmt,
+     nkFromStmt, nkTemplateDef, nkMacroDef, nkStaticStmt,
      nkMixinStmt, nkBindStmt: discard
+  of nkIteratorDef:
+    if n[0].sym.typ.callConv == TCallingConvention.ccClosure:
+      globalError(p.config, n.info, "Closure iterators are not supported by JS backend!")
   of nkPragma: genPragma(p, n)
   of nkProcDef, nkFuncDef, nkMethodDef, nkConverterDef:
     var s = n[namePos].sym
@@ -3057,9 +2998,7 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
       genSym(p, n[namePos], r)
       r.res = ""
   of nkGotoState, nkState:
-    globalError(p.config, n.info, "not implemented")
-  of nkBreakState:
-    genBreakState(p, n[0], r)
+    globalError(p.config, n.info, "First class iterators not implemented")
   of nkPragmaBlock: gen(p, n.lastSon, r)
   of nkComesFrom:
     discard "XXX to implement for better stack traces"
@@ -3166,6 +3105,15 @@ proc wholeCode(graph: ModuleGraph; m: BModule): Rope =
 
   result = globals.typeInfo & globals.constants & globals.code
 
+proc getClassName(t: PType): Rope =
+  var s = t.sym
+  if s.isNil or sfAnon in s.flags:
+    s = skipTypes(t, abstractPtrs).sym
+  if s.isNil or sfAnon in s.flags:
+    doAssert(false, "cannot retrieve class name")
+  if s.loc.r != "": result = s.loc.r
+  else: result = rope(s.name.s)
+
 proc finalJSCodeGen*(graph: ModuleGraph; b: PPassContext, n: PNode): PNode =
   ## Finalize JS code generation of a Nim module.
   ## Param `n` may contain nodes returned from the last module close call.

compiler/jstypes.nim

@@ -69,7 +69,7 @@ proc genObjectFields(p: PProc, typ: PType, n: PNode): Rope =
   else: internalError(p.config, n.info, "genObjectFields")
 
 proc objHasTypeField(t: PType): bool {.inline.} =
-  tfInheritable in t.flags or t.baseClass != nil
+  tfInheritable in t.flags or t[0] != nil
 
 proc genObjectInfo(p: PProc, typ: PType, name: Rope) =
   let kind = if objHasTypeField(typ): tyObject else: tyTuple
@@ -79,9 +79,9 @@ proc genObjectInfo(p: PProc, typ: PType, name: Rope) =
   p.g.typeInfo.addf("var NNI$1 = $2;$n",
        [rope(typ.id), genObjectFields(p, typ, typ.n)])
   p.g.typeInfo.addf("$1.node = NNI$2;$n", [name, rope(typ.id)])
-  if (typ.kind == tyObject) and (typ.baseClass != nil):
+  if (typ.kind == tyObject) and (typ[0] != nil):
     p.g.typeInfo.addf("$1.base = $2;$n",
-         [name, genTypeInfo(p, typ.baseClass.skipTypes(skipPtrs))])
+         [name, genTypeInfo(p, typ[0].skipTypes(skipPtrs))])
 
 proc genTupleFields(p: PProc, typ: PType): Rope =
   var s: Rope = ""
@@ -117,9 +117,9 @@ proc genEnumInfo(p: PProc, typ: PType, name: Rope) =
   prepend(p.g.typeInfo, s)
   p.g.typeInfo.add(n)
   p.g.typeInfo.addf("$1.node = NNI$2;$n", [name, rope(typ.id)])
-  if typ.baseClass != nil:
+  if typ[0] != nil:
     p.g.typeInfo.addf("$1.base = $2;$n",
-         [name, genTypeInfo(p, typ.baseClass)])
+         [name, genTypeInfo(p, typ[0])])
 
 proc genTypeInfo(p: PProc, typ: PType): Rope =
   let t = typ.skipTypes({tyGenericInst, tyDistinct, tyAlias, tySink, tyOwned})
@@ -127,7 +127,7 @@ proc genTypeInfo(p: PProc, typ: PType): Rope =
   if containsOrIncl(p.g.typeInfoGenerated, t.id): return
   case t.kind
   of tyDistinct:
-    result = genTypeInfo(p, t.skipModifier)
+    result = genTypeInfo(p, t[0])
   of tyPointer, tyProc, tyBool, tyChar, tyCstring, tyString, tyInt..tyUInt64:
     var s =
       "var $1 = {size: 0,kind: $2,base: null,node: null,finalizer: null};$n" %
@@ -139,18 +139,18 @@ proc genTypeInfo(p: PProc, typ: PType): Rope =
               [result, rope(ord(t.kind))]
     prepend(p.g.typeInfo, s)
     p.g.typeInfo.addf("$1.base = $2;$n",
-         [result, genTypeInfo(p, t.elementType)])
+         [result, genTypeInfo(p, t.lastSon)])
   of tyArray:
     var s =
       "var $1 = {size: 0, kind: $2, base: null, node: null, finalizer: null};$n" %
               [result, rope(ord(t.kind))]
     prepend(p.g.typeInfo, s)
     p.g.typeInfo.addf("$1.base = $2;$n",
-         [result, genTypeInfo(p, t.elementType)])
+         [result, genTypeInfo(p, t[1])])
   of tyEnum: genEnumInfo(p, t, result)
   of tyObject: genObjectInfo(p, t, result)
   of tyTuple: genTupleInfo(p, t, result)
   of tyStatic:
-    if t.n != nil: result = genTypeInfo(p, skipModifier t)
+    if t.n != nil: result = genTypeInfo(p, lastSon t)
     else: internalError(p.config, "genTypeInfo(" & $t.kind & ')')
   else: internalError(p.config, "genTypeInfo(" & $t.kind & ')')

compiler/lambdalifting.nim

@@ -145,13 +145,11 @@ proc createStateField(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym =
   result = newSym(skField, getIdent(g.cache, ":state"), idgen, iter, iter.info)
   result.typ = createClosureIterStateType(g, iter, idgen)
 
-template isIterator*(owner: PSym): bool =
-  owner.kind == skIterator and owner.typ.callConv == ccClosure
-
 proc createEnvObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo): PType =
+  # YYY meh, just add the state field for every closure for now, it's too
+  # hard to figure out if it comes from a closure iterator:
   result = createObj(g, idgen, owner, info, final=false)
-  if owner.isIterator:
-    rawAddField(result, createStateField(g, owner, idgen))
+  rawAddField(result, createStateField(g, owner, idgen))
 
 proc getClosureIterResult*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym =
   if resultPos < iter.ast.len:
@@ -159,7 +157,7 @@ proc getClosureIterResult*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym
   else:
     # XXX a bit hacky:
     result = newSym(skResult, getIdent(g.cache, ":result"), idgen, iter, iter.info, {})
-    result.typ = iter.typ.returnType
+    result.typ = iter.typ[0]
     incl(result.flags, sfUsed)
     iter.ast.add newSymNode(result)
 
@@ -174,23 +172,26 @@ proc addHiddenParam(routine: PSym, param: PSym) =
   assert sfFromGeneric in param.flags
   #echo "produced environment: ", param.id, " for ", routine.id
 
-proc getEnvParam*(routine: PSym): PSym =
-  if routine.ast.isNil: return nil
+proc getHiddenParam(g: ModuleGraph; routine: PSym): PSym =
   let params = routine.ast[paramsPos]
   let hidden = lastSon(params)
   if hidden.kind == nkSym and hidden.sym.kind == skParam and hidden.sym.name.s == paramName:
     result = hidden.sym
     assert sfFromGeneric in result.flags
   else:
-    result = nil
-
-proc getHiddenParam(g: ModuleGraph; routine: PSym): PSym =
-  result = getEnvParam(routine)
-  if result.isNil:
     # writeStackTrace()
     localError(g.config, routine.info, "internal error: could not find env param for " & routine.name.s)
     result = routine
 
+proc getEnvParam*(routine: PSym): PSym =
+  let params = routine.ast[paramsPos]
+  let hidden = lastSon(params)
+  if hidden.kind == nkSym and hidden.sym.name.s == paramName:
+    result = hidden.sym
+    assert sfFromGeneric in result.flags
+  else:
+    result = nil
+
 proc interestingVar(s: PSym): bool {.inline.} =
   result = s.kind in {skVar, skLet, skTemp, skForVar, skParam, skResult} and
     sfGlobal notin s.flags and
@@ -229,14 +230,23 @@ proc makeClosure*(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; inf
   if tfHasAsgn in result.typ.flags or optSeqDestructors in g.config.globalOptions:
     prc.flags.incl sfInjectDestructors
 
-template liftingHarmful(conf: ConfigRef; owner: PSym): bool =
+proc interestingIterVar(s: PSym): bool {.inline.} =
+  # XXX optimization: Only lift the variable if it lives across
+  # yield/return boundaries! This can potentially speed up
+  # closure iterators quite a bit.
+  result = s.kind in {skResult, skVar, skLet, skTemp, skForVar} and sfGlobal notin s.flags
+
+template isIterator*(owner: PSym): bool =
+  owner.kind == skIterator and owner.typ.callConv == ccClosure
+
+proc liftingHarmful(conf: ConfigRef; owner: PSym): bool {.inline.} =
   ## lambda lifting can be harmful for JS-like code generators.
   let isCompileTime = sfCompileTime in owner.flags or owner.kind == skMacro
-  jsNoLambdaLifting in conf.legacyFeatures and conf.backend == backendJs and not isCompileTime
+  result = conf.backend == backendJs and not isCompileTime
 
 proc createTypeBoundOpsLL(g: ModuleGraph; refType: PType; info: TLineInfo; idgen: IdGenerator; owner: PSym) =
   if owner.kind != skMacro:
-    createTypeBoundOps(g, nil, refType.elementType, info, idgen)
+    createTypeBoundOps(g, nil, refType.lastSon, info, idgen)
     createTypeBoundOps(g, nil, refType, info, idgen)
     if tfHasAsgn in refType.flags or optSeqDestructors in g.config.globalOptions:
       owner.flags.incl sfInjectDestructors
@@ -254,7 +264,8 @@ proc liftIterSym*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PN
   let iter = n.sym
   assert iter.isIterator
 
-  result = newNodeIT(nkStmtListExpr, n.info, iter.typ)
+  result = newNodeIT(nkStmtListExpr, n.info, n.typ)
+
   let hp = getHiddenParam(g, iter)
   var env: PNode
   if owner.isIterator:
@@ -275,6 +286,15 @@ proc liftIterSym*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PN
   createTypeBoundOpsLL(g, env.typ, n.info, idgen, owner)
   result.add makeClosure(g, idgen, iter, env, n.info)
 
+proc freshVarForClosureIter*(g: ModuleGraph; s: PSym; idgen: IdGenerator; owner: PSym): PNode =
+  let envParam = getHiddenParam(g, owner)
+  let obj = envParam.typ.skipTypes({tyOwned, tyRef, tyPtr})
+  let field = addField(obj, s, g.cache, idgen)
+
+  var access = newSymNode(envParam)
+  assert obj.kind == tyObject
+  result = rawIndirectAccess(access, field, s.info)
+
 # ------------------ new stuff -------------------------------------------
 
 proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
@@ -284,8 +304,8 @@ proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
     localError(g.config, n.info,
       ("'$1' is of type <$2> which cannot be captured as it would violate memory" &
        " safety, declared here: $3; using '-d:nimNoLentIterators' helps in some cases." &
-       " Consider using a <ref T> which can be captured.") %
-      [s.name.s, typeToString(s.typ.skipTypes({tyVar})), g.config$s.info])
+       " Consider using a <ref $2> which can be captured.") %
+      [s.name.s, typeToString(s.typ), g.config$s.info])
   elif not (owner.typ.isClosure or owner.isNimcall and not owner.isExplicitCallConv or isEnv):
     localError(g.config, n.info, "illegal capture '$1' because '$2' has the calling convention: <$3>" %
       [s.name.s, owner.name.s, $owner.typ.callConv])
@@ -322,13 +342,9 @@ proc getEnvTypeForOwner(c: var DetectionPass; owner: PSym;
                         info: TLineInfo): PType =
   result = c.ownerToType.getOrDefault(owner.id)
   if result.isNil:
-    let env = getEnvParam(owner)
-    if env.isNil or not owner.isIterator:
-      result = newType(tyRef, c.idgen, owner)
-      let obj = createEnvObj(c.graph, c.idgen, owner, info)
-      rawAddSon(result, obj)
-    else:
-      result = env.typ
+    result = newType(tyRef, c.idgen, owner)
+    let obj = createEnvObj(c.graph, c.idgen, owner, info)
+    rawAddSon(result, obj)
     c.ownerToType[owner.id] = result
 
 proc asOwnedRef(c: var DetectionPass; t: PType): PType =
@@ -420,12 +436,6 @@ proc addClosureParam(c: var DetectionPass; fn: PSym; info: TLineInfo) =
     localError(c.graph.config, fn.info, "internal error: inconsistent environment type")
   #echo "adding closure to ", fn.name.s
 
-proc iterEnvHasUpField(g: ModuleGraph, iter: PSym): bool =
-  let cp = getEnvParam(iter)
-  doAssert(cp != nil, "Env param not present in iter")
-  let upField = lookupInRecord(cp.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(g.cache, upName))
-  upField != nil
-
 proc detectCapturedVars(n: PNode; owner: PSym; c: var DetectionPass) =
   case n.kind
   of nkSym:
@@ -444,12 +454,22 @@ proc detectCapturedVars(n: PNode; owner: PSym; c: var DetectionPass) =
         let body = transformBody(c.graph, c.idgen, s, {useCache})
         detectCapturedVars(body, s, c)
     let ow = s.skipGenericOwner
-    let innerClosure = innerProc and s.typ.callConv == ccClosure and (not s.isIterator or iterEnvHasUpField(c.graph, s))
+    let innerClosure = innerProc and s.typ.callConv == ccClosure and not s.isIterator
     let interested = interestingVar(s)
     if ow == owner:
       if owner.isIterator:
         c.somethingToDo = true
         addClosureParam(c, owner, n.info)
+        if interestingIterVar(s):
+          if not c.capturedVars.contains(s.id):
+            if not c.inTypeOf: c.capturedVars.incl(s.id)
+            let obj = getHiddenParam(c.graph, owner).typ.skipTypes({tyOwned, tyRef, tyPtr})
+            #let obj = c.getEnvTypeForOwner(s.owner).skipTypes({tyOwned, tyRef, tyPtr})
+
+            if s.name.id == getIdent(c.graph.cache, ":state").id:
+              obj.n[0].sym.itemId = ItemId(module: s.itemId.module, item: -s.itemId.item)
+            else:
+              discard addField(obj, s, c.graph.cache, c.idgen)
     # direct or indirect dependency:
     elif innerClosure or interested:
       discard """
@@ -531,8 +551,8 @@ proc accessViaEnvParam(g: ModuleGraph; n: PNode; owner: PSym): PNode =
   let envParam = getHiddenParam(g, owner)
   if not envParam.isNil:
     var access = newSymNode(envParam)
-    var obj = access.typ.elementType
     while true:
+      let obj = access.typ[0]
       assert obj.kind == tyObject
       let field = getFieldFromObj(obj, s)
       if field != nil:
@@ -540,7 +560,6 @@ proc accessViaEnvParam(g: ModuleGraph; n: PNode; owner: PSym): PNode =
       let upField = lookupInRecord(obj.n, getIdent(g.cache, upName))
       if upField == nil: break
       access = rawIndirectAccess(access, upField, n.info)
-      obj = access.typ.baseClass
   localError(g.config, n.info, "internal error: environment misses: " & s.name.s)
   result = n
 
@@ -552,7 +571,7 @@ proc newEnvVar(cache: IdentCache; owner: PSym; typ: PType; info: TLineInfo; idge
   when false:
     if owner.kind == skIterator and owner.typ.callConv == ccClosure:
       let it = getHiddenParam(owner)
-      addUniqueField(it.typ.elementType, v)
+      addUniqueField(it.typ[0], v)
       result = indirectAccess(newSymNode(it), v, v.info)
     else:
       result = newSymNode(v)
@@ -609,7 +628,7 @@ proc rawClosureCreation(owner: PSym;
       let unowned = c.unownedEnvVars[owner.id]
       assert unowned != nil
       let env2 = copyTree(env)
-      env2.typ() = unowned.typ
+      env2.typ = unowned.typ
       result.add newAsgnStmt(unowned, env2, env.info)
       createTypeBoundOpsLL(d.graph, unowned.typ, env.info, d.idgen, owner)
 
@@ -649,27 +668,16 @@ proc finishClosureCreation(owner: PSym; d: var DetectionPass; c: LiftingPass;
     res.add newAsgnStmt(unowned, nilLit, info)
     createTypeBoundOpsLL(d.graph, unowned.typ, info, d.idgen, owner)
 
-proc getUpForIter(g: ModuleGraph; owner, iterOwner: PSym, expectedUpTyp: PType): PNode =
-  var p = getHiddenParam(g, owner)
-  var res = p.newSymNode
-  while res.typ.skipTypes({tyOwned, tyRef, tyPtr}) != expectedUpTyp:
-    let upField = lookupInRecord(p.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(g.cache, upName))
-    if upField == nil:
-      return nil
-    p = upField
-    res = rawIndirectAccess(res, upField, p.info)
-  res
-
-proc closureCreationForIter(owner: PSym, iter: PNode;
+proc closureCreationForIter(iter: PNode;
                             d: var DetectionPass; c: var LiftingPass): PNode =
   result = newNodeIT(nkStmtListExpr, iter.info, iter.sym.typ)
-  let iterOwner = iter.sym.skipGenericOwner
-  var v = newSym(skVar, getIdent(d.graph.cache, envName), d.idgen, iterOwner, iter.info)
+  let owner = iter.sym.skipGenericOwner
+  var v = newSym(skVar, getIdent(d.graph.cache, envName), d.idgen, owner, iter.info)
   incl(v.flags, sfShadowed)
   v.typ = asOwnedRef(d, getHiddenParam(d.graph, iter.sym).typ)
   var vnode: PNode
-  if iterOwner.isIterator:
-    let it = getHiddenParam(d.graph, iterOwner)
+  if owner.isIterator:
+    let it = getHiddenParam(d.graph, owner)
     addUniqueField(it.typ.skipTypes({tyOwned, tyRef, tyPtr}), v, d.graph.cache, d.idgen)
     vnode = indirectAccess(newSymNode(it), v, v.info)
   else:
@@ -678,14 +686,12 @@ proc closureCreationForIter(owner: PSym, iter: PNode;
     addVar(vs, vnode)
     result.add(vs)
   result.add genCreateEnv(vnode)
-  createTypeBoundOpsLL(d.graph, vnode.typ, iter.info, d.idgen, iterOwner)
+  createTypeBoundOpsLL(d.graph, vnode.typ, iter.info, d.idgen, owner)
 
   let upField = lookupInRecord(v.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(d.graph.cache, upName))
   if upField != nil:
-    let expectedUpTyp = upField.typ.skipTypes({tyOwned, tyRef, tyPtr})
-    let u = if iterOwner == owner: setupEnvVar(iterOwner, d, c, iter.info)
-            else: getUpForIter(d.graph, owner, iterOwner, expectedUpTyp)
-    if u != nil and u.typ.skipTypes({tyOwned, tyRef, tyPtr}) == expectedUpTyp:
+    let u = setupEnvVar(owner, d, c, iter.info)
+    if u.typ.skipTypes({tyOwned, tyRef, tyPtr}) == upField.typ.skipTypes({tyOwned, tyRef, tyPtr}):
       result.add(newAsgnStmt(rawIndirectAccess(vnode, upField, iter.info),
                  u, iter.info))
     else:
@@ -719,7 +725,7 @@ proc symToClosure(n: PNode; owner: PSym; d: var DetectionPass;
     let available = getHiddenParam(d.graph, owner)
     result = makeClosure(d.graph, d.idgen, s, available.newSymNode, n.info)
   elif s.isIterator:
-    result = closureCreationForIter(owner, n, d, c)
+    result = closureCreationForIter(n, d, c)
   elif s.skipGenericOwner == owner:
     # direct dependency, so use the outer's env variable:
     result = makeClosure(d.graph, d.idgen, s, setupEnvVar(owner, d, c, n.info), n.info)
@@ -766,6 +772,8 @@ proc liftCapturedVars(n: PNode; owner: PSym; d: var DetectionPass;
     elif s.id in d.capturedVars:
       if s.owner != owner:
         result = accessViaEnvParam(d.graph, n, owner)
+      elif owner.isIterator and interestingIterVar(s):
+        result = accessViaEnvParam(d.graph, n, owner)
       else:
         result = accessViaEnvVar(n, owner, d, c)
   of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit, nkComesFrom,
@@ -786,7 +794,7 @@ proc liftCapturedVars(n: PNode; owner: PSym; d: var DetectionPass;
       let oldInContainer = c.inContainer
       c.inContainer = 0
       let m = newSymNode(n[namePos].sym)
-      m.typ() = n.typ
+      m.typ = n.typ
       result = liftCapturedVars(m, owner, d, c)
       c.inContainer = oldInContainer
   of nkHiddenStdConv:
@@ -874,18 +882,19 @@ proc liftIterToProc*(g: ModuleGraph; fn: PSym; body: PNode; ptrType: PType;
 
 proc liftLambdas*(g: ModuleGraph; fn: PSym, body: PNode; tooEarly: var bool;
                   idgen: IdGenerator; flags: TransformFlags): PNode =
+  # XXX backend == backendJs does not suffice! The compiletime stuff needs
+  # the transformation even when compiling to JS ...
+
+  # However we can do lifting for the stuff which is *only* compiletime.
   let isCompileTime = sfCompileTime in fn.flags or fn.kind == skMacro
 
-  if body.kind == nkEmpty or (jsNoLambdaLifting in g.config.legacyFeatures and
+  if body.kind == nkEmpty or (
       g.config.backend == backendJs and not isCompileTime) or
       (fn.skipGenericOwner.kind != skModule and force notin flags):
 
     # ignore forward declaration:
     result = body
     tooEarly = true
-    if fn.isIterator:
-      var d = initDetectionPass(g, fn, idgen)
-      addClosureParam(d, fn, body.info)
   else:
     var d = initDetectionPass(g, fn, idgen)
     detectCapturedVars(body, fn, d)
@@ -984,15 +993,12 @@ proc liftForLoop*(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner: PSym):
   # gather vars in a tuple:
   var v2 = newNodeI(nkLetSection, body.info)
   var vpart = newNodeI(if body.len == 3: nkIdentDefs else: nkVarTuple, body.info)
-  if body.len == 3 and body[0].kind == nkVarTuple:
-    vpart = body[0] # fixes for (i,j) in walk() # bug #15924
-  else:
-    for i in 0..<body.len-2:
-      if body[i].kind == nkSym:
-        body[i].sym.transitionToLet()
-      vpart.add body[i]
+  for i in 0..<body.len-2:
+    if body[i].kind == nkSym:
+      body[i].sym.transitionToLet()
+    vpart.add body[i]
 
-    vpart.add newNodeI(nkEmpty, body.info) # no explicit type
+  vpart.add newNodeI(nkEmpty, body.info) # no explicit type
   if not env.isNil:
     call[0] = makeClosure(g, idgen, call[0].sym, env.newSymNode, body.info)
   vpart.add call

compiler/layeredtable.nim

@@ -1,82 +0,0 @@
-import std/tables
-import ast
-
-type
-  LayeredIdTableObj* {.acyclic.} = object
-    ## stack of type binding contexts implemented as a linked list
-    topLayer*: TypeMapping
-      ## the mappings on the current layer
-    nextLayer*: ref LayeredIdTableObj
-      ## the parent type binding context, possibly `nil`
-    previousLen*: int
-      ## total length of the bindings up to the parent layer,
-      ## used to track if new bindings were added
-
-const useRef = not defined(gcDestructors)
-  # implementation detail, only arc/orc doesn't cause issues when
-  # using LayeredIdTable as an object and not a ref
-
-when useRef:
-  type LayeredIdTable* = ref LayeredIdTableObj
-else:
-  type LayeredIdTable* = LayeredIdTableObj
-
-proc initLayeredTypeMap*(pt: sink TypeMapping = initTypeMapping()): LayeredIdTable =
-  result = LayeredIdTable(topLayer: pt, nextLayer: nil)
-
-proc shallowCopy*(pt: LayeredIdTable): LayeredIdTable {.inline.} =
-  ## copies only the type bindings of the current layer, but not any parent layers,
-  ## useful for write-only bindings
-  result = LayeredIdTable(topLayer: pt.topLayer, nextLayer: pt.nextLayer, previousLen: pt.previousLen)
-
-proc currentLen*(pt: LayeredIdTable): int =
-  ## the sum of the cached total binding count of the parents and
-  ## the current binding count, just used to track if bindings were added
-  pt.previousLen + pt.topLayer.len
-
-proc newTypeMapLayer*(pt: LayeredIdTable): LayeredIdTable =
-  result = LayeredIdTable(topLayer: initTable[ItemId, PType](), previousLen: pt.currentLen)
-  when useRef:
-    result.nextLayer = pt
-  else:
-    new(result.nextLayer)
-    result.nextLayer[] = pt
-
-proc setToPreviousLayer*(pt: var LayeredIdTable) {.inline.} =
-  when useRef:
-    pt = pt.nextLayer
-  else:
-    when defined(gcDestructors):
-      pt = pt.nextLayer[]
-    else:
-      # workaround refc
-      let tmp = pt.nextLayer[]
-      pt = tmp
-
-proc lookup(typeMap: ref LayeredIdTableObj, key: ItemId): PType =
-  result = nil
-  var tm = typeMap
-  while tm != nil:
-    result = getOrDefault(tm.topLayer, key)
-    if result != nil: return
-    tm = tm.nextLayer
-
-template lookup*(typeMap: ref LayeredIdTableObj, key: PType): PType =
-  ## recursively looks up binding of `key` in all parent layers
-  lookup(typeMap, key.itemId)
-
-when not useRef:
-  proc lookup(typeMap: LayeredIdTableObj, key: ItemId): PType {.inline.} =
-    result = getOrDefault(typeMap.topLayer, key)
-    if result == nil and typeMap.nextLayer != nil:
-      result = lookup(typeMap.nextLayer, key)
-
-  template lookup*(typeMap: LayeredIdTableObj, key: PType): PType =
-    lookup(typeMap, key.itemId)
-
-proc put(typeMap: var LayeredIdTable, key: ItemId, value: PType) {.inline.} =
-  typeMap.topLayer[key] = value
-
-template put*(typeMap: var LayeredIdTable, key, value: PType) =
-  ## binds `key` to `value` only in current layer
-  put(typeMap, key.itemId, value)

compiler/layouter.nim

@@ -9,7 +9,7 @@
 
 ## Layouter for nimpretty.
 
-import idents, lexer, ast, lineinfos, llstream, options, msgs, strutils, pathutils
+import idents, lexer, lineinfos, llstream, options, msgs, strutils, pathutils
 
 const
   MinLineLen = 15
@@ -243,28 +243,23 @@ proc renderTokens*(em: var Emitter): string =
 
   return content
 
-type
-  FinalCheck = proc (content: string; origAst: PNode): bool {.nimcall.}
-
-proc writeOut*(em: Emitter; content: string; origAst: PNode; check: FinalCheck) =
+proc writeOut*(em: Emitter, content: string)  =
   ## Write to disk
   let outFile = em.config.absOutFile
   if fileExists(outFile) and readFile(outFile.string) == content:
     discard "do nothing, see #9499"
     return
+  var f = llStreamOpen(outFile, fmWrite)
+  if f == nil:
+    rawMessage(em.config, errGenerated, "cannot open file: " & outFile.string)
+    return
+  f.llStreamWrite content
+  llStreamClose(f)
 
-  if check(content, origAst):
-    var f = llStreamOpen(outFile, fmWrite)
-    if f == nil:
-      rawMessage(em.config, errGenerated, "cannot open file: " & outFile.string)
-      return
-    f.llStreamWrite content
-    llStreamClose(f)
-
-proc closeEmitter*(em: var Emitter; origAst: PNode; check: FinalCheck) =
+proc closeEmitter*(em: var Emitter) =
   ## Renders emitter tokens and write to a file
   let content = renderTokens(em)
-  em.writeOut(content, origAst, check)
+  em.writeOut(content)
 
 proc wr(em: var Emitter; x: string; lt: LayoutToken) =
   em.tokens.add x

compiler/lexer.nim

@@ -300,7 +300,8 @@ proc getNumber(L: var Lexer, result: var Token) =
     # Used to get slightly human friendlier err messages.
     const literalishChars = {'A'..'Z', 'a'..'z', '0'..'9', '_', '.', '\''}
     var msgPos = L.bufpos
-    var t = Token(literal: "")
+    var t: Token
+    t.literal = ""
     L.bufpos = startpos # Use L.bufpos as pos because of matchChars
     matchChars(L, t, literalishChars)
     # We must verify +/- specifically so that we're not past the literal

compiler/liftdestructors.nim

@@ -40,7 +40,7 @@ template asink*(t: PType): PSym = getAttachedOp(c.g, t, attachedSink)
 
 proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode)
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator; isDistinct = false): PSym
+              info: TLineInfo; idgen: IdGenerator): PSym
 
 proc createTypeBoundOps*(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo;
                          idgen: IdGenerator)
@@ -49,17 +49,17 @@ proc at(a, i: PNode, elemType: PType): PNode =
   result = newNodeI(nkBracketExpr, a.info, 2)
   result[0] = a
   result[1] = i
-  result.typ() = elemType
+  result.typ = elemType
 
 proc destructorOverridden(g: ModuleGraph; t: PType): bool =
   let op = getAttachedOp(g, t, attachedDestructor)
   op != nil and sfOverridden in op.flags
 
 proc fillBodyTup(c: var TLiftCtx; t: PType; body, x, y: PNode) =
-  for i, a in t.ikids:
+  for i in 0..<t.len:
     let lit = lowerings.newIntLit(c.g, x.info, i)
-    let b = if c.kind == attachedTrace: y else: y.at(lit, a)
-    fillBody(c, a, body, x.at(lit, a), b)
+    let b = if c.kind == attachedTrace: y else: y.at(lit, t[i])
+    fillBody(c, t[i], body, x.at(lit, t[i]), b)
 
 proc dotField(x: PNode, f: PSym): PNode =
   result = newNodeI(nkDotExpr, x.info, 2)
@@ -68,7 +68,7 @@ proc dotField(x: PNode, f: PSym): PNode =
   else:
     result[0] = x
   result[1] = newSymNode(f, x.info)
-  result.typ() = f.typ
+  result.typ = f.typ
 
 proc newAsgnStmt(le, ri: PNode): PNode =
   result = newNodeI(nkAsgn, le.info, 2)
@@ -88,7 +88,7 @@ proc defaultOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add newAsgnStmt(x, y)
   elif c.kind == attachedDestructor and c.addMemReset:
     let call = genBuiltin(c, mDefault, "default", x)
-    call.typ() = t
+    call.typ = t
     body.add newAsgnStmt(x, call)
   elif c.kind == attachedWasMoved:
     body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
@@ -105,7 +105,7 @@ proc genWhileLoop(c: var TLiftCtx; i, dest: PNode): PNode =
   result = newNodeI(nkWhileStmt, c.info, 2)
   let cmp = genBuiltin(c, mLtI, "<", i)
   cmp.add genLen(c.g, dest)
-  cmp.typ() = getSysType(c.g, c.info, tyBool)
+  cmp.typ = getSysType(c.g, c.info, tyBool)
   result[0] = cmp
   result[1] = newNodeI(nkStmtList, c.info)
 
@@ -127,10 +127,10 @@ proc genContainerOf(c: var TLiftCtx; objType: PType, field, x: PSym): PNode =
   dotExpr.add newSymNode(field)
 
   let offsetOf = genBuiltin(c, mOffsetOf, "offsetof", dotExpr)
-  offsetOf.typ() = intType
+  offsetOf.typ = intType
 
   let minusExpr = genBuiltin(c, mSubI, "-", castExpr1)
-  minusExpr.typ() = intType
+  minusExpr.typ = intType
   minusExpr.add offsetOf
 
   let objPtr = makePtrType(objType.owner, objType, c.idgen)
@@ -139,9 +139,9 @@ proc genContainerOf(c: var TLiftCtx; objType: PType, field, x: PSym): PNode =
   result.add minusExpr
 
 proc destructorCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
-  var destroy = newNodeIT(nkCall, x.info, op.typ.returnType)
+  var destroy = newNodeIT(nkCall, x.info, op.typ[0])
   destroy.add(newSymNode(op))
-  if op.typ.firstParamType.kind != tyVar:
+  if op.typ[1].kind != tyVar:
     destroy.add x
   else:
     destroy.add genAddr(c, x)
@@ -153,11 +153,11 @@ proc destructorCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
     result = destroy
 
 proc genWasMovedCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
-  result = newNodeIT(nkCall, x.info, op.typ.returnType)
+  result = newNodeIT(nkCall, x.info, op.typ[0])
   result.add(newSymNode(op))
   result.add genAddr(c, x)
 
-proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool, enforceWasMoved = false) =
+proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool) =
   case n.kind
   of nkSym:
     if c.filterDiscriminator != nil: return
@@ -167,8 +167,6 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
         enforceDefaultOp:
       defaultOp(c, f.typ, body, x.dotField(f), b)
     else:
-      if enforceWasMoved:
-        body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x.dotField(f))
       fillBody(c, f.typ, body, x.dotField(f), b)
   of nkNilLit: discard
   of nkRecCase:
@@ -207,7 +205,7 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
       branch[^1] = newNodeI(nkStmtList, c.info)
 
       fillBodyObj(c, n[i].lastSon, branch[^1], x, y,
-                  enforceDefaultOp = localEnforceDefaultOp, enforceWasMoved = c.kind == attachedAsgn)
+                  enforceDefaultOp = localEnforceDefaultOp)
       if branch[^1].len == 0: inc emptyBranches
       caseStmt.add(branch)
     if emptyBranches != n.len-1:
@@ -218,29 +216,20 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
       fillBodyObj(c, n[0], body, x, y, enforceDefaultOp = false)
     c.filterDiscriminator = oldfilterDiscriminator
   of nkRecList:
-    for t in items(n): fillBodyObj(c, t, body, x, y, enforceDefaultOp, enforceWasMoved)
+    for t in items(n): fillBodyObj(c, t, body, x, y, enforceDefaultOp)
   else:
     illFormedAstLocal(n, c.g.config)
 
 proc fillBodyObjTImpl(c: var TLiftCtx; t: PType, body, x, y: PNode) =
-  if t.baseClass != nil:
-    let dest = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
-    dest.add newNodeI(nkEmpty, c.info)
-    dest.add x
-    var src = y
-    if c.kind in {attachedAsgn, attachedDeepCopy, attachedSink}:
-      src = newNodeIT(nkHiddenSubConv, c.info, t.baseClass)
-      src.add newNodeI(nkEmpty, c.info)
-      src.add y
-
-    fillBody(c, skipTypes(t.baseClass, abstractPtrs), body, dest, src)
+  if t.len > 0 and t[0] != nil:
+    fillBody(c, skipTypes(t[0], abstractPtrs), body, x, y)
   fillBodyObj(c, t.n, body, x, y, enforceDefaultOp = false)
 
 proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
   var hasCase = isCaseObj(t.n)
   var obj = t
-  while obj.baseClass != nil:
-    obj = skipTypes(obj.baseClass, abstractPtrs)
+  while obj.len > 0 and obj[0] != nil:
+    obj = skipTypes(obj[0], abstractPtrs)
     hasCase = hasCase or isCaseObj(obj.n)
 
   if hasCase and c.kind in {attachedAsgn, attachedDeepCopy}:
@@ -265,7 +254,7 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
       # because the wasMoved(dest) call would zero out src, if dest aliases src.
       var cond = newTree(nkCall, newSymNode(c.g.getSysMagic(c.info, "==", mEqRef)),
         newTreeIT(nkAddr, c.info, makePtrType(c.fn, x.typ, c.idgen), x), newTreeIT(nkAddr, c.info, makePtrType(c.fn, y.typ, c.idgen), y))
-      cond.typ() = getSysType(c.g, x.info, tyBool)
+      cond.typ = getSysType(c.g, x.info, tyBool)
       body.add genIf(c, cond, newTreeI(nkReturnStmt, c.info, newNodeI(nkEmpty, c.info)))
     var temp = newSym(skTemp, getIdent(c.g.cache, lowerings.genPrefix), c.idgen, c.fn, c.info)
     temp.typ = x.typ
@@ -290,17 +279,16 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
     c.kind = attachedDestructor
     fillBodyObjTImpl(c, t, body, blob, y)
     c.kind = prevKind
-
   else:
     fillBodyObjTImpl(c, t, body, x, y)
 
 proc boolLit*(g: ModuleGraph; info: TLineInfo; value: bool): PNode =
   result = newIntLit(g, info, ord value)
-  result.typ() = getSysType(g, info, tyBool)
+  result.typ = getSysType(g, info, tyBool)
 
 proc getCycleParam(c: TLiftCtx): PNode =
   assert c.kind in {attachedAsgn, attachedDup}
-  if c.fn.typ.len == 3 + ord(c.kind == attachedAsgn):
+  if c.fn.typ.len == 4:
     result = c.fn.typ.n.lastSon
     assert result.kind == nkSym
     assert result.sym.name.s == "cyclic"
@@ -314,35 +302,27 @@ proc newHookCall(c: var TLiftCtx; op: PSym; x, y: PNode): PNode =
   result.add newSymNode(op)
   if sfNeverRaises notin op.flags:
     c.canRaise = true
-  if op.typ.firstParamType.kind == tyVar:
+  if op.typ[1].kind == tyVar:
     result.add genAddr(c, x)
   else:
     result.add x
   if y != nil:
     result.add y
-  if op.typ.signatureLen == 4:
+  if op.typ.len == 4:
     assert y != nil
-    if c.fn.typ.signatureLen == 4:
+    if c.fn.typ.len == 4:
       result.add getCycleParam(c)
     else:
       # assume the worst: A cycle is created:
       result.add boolLit(c.g, y.info, true)
 
 proc newOpCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
-  result = newNodeIT(nkCall, x.info, op.typ.returnType)
+  result = newNodeIT(nkCall, x.info, op.typ[0])
   result.add(newSymNode(op))
   result.add x
   if sfNeverRaises notin op.flags:
     c.canRaise = true
 
-  if c.kind == attachedDup and op.typ.len == 3:
-    assert x != nil
-    if c.fn.typ.len == 3:
-      result.add getCycleParam(c)
-    else:
-      # assume the worst: A cycle is created:
-      result.add boolLit(c.g, x.info, true)
-
 proc newDeepCopyCall(c: var TLiftCtx; op: PSym; x, y: PNode): PNode =
   result = newAsgnStmt(x, newOpCall(c, op, y))
 
@@ -545,18 +525,18 @@ proc newSeqCall(c: var TLiftCtx; x, y: PNode): PNode =
   # don't call genAddr(c, x) here:
   result = genBuiltin(c, mNewSeq, "newSeq", x)
   let lenCall = genBuiltin(c, mLengthSeq, "len", y)
-  lenCall.typ() = getSysType(c.g, x.info, tyInt)
+  lenCall.typ = getSysType(c.g, x.info, tyInt)
   result.add lenCall
 
 proc setLenStrCall(c: var TLiftCtx; x, y: PNode): PNode =
   let lenCall = genBuiltin(c, mLengthStr, "len", y)
-  lenCall.typ() = getSysType(c.g, x.info, tyInt)
+  lenCall.typ = getSysType(c.g, x.info, tyInt)
   result = genBuiltin(c, mSetLengthStr, "setLen", x) # genAddr(g, x))
   result.add lenCall
 
 proc setLenSeqCall(c: var TLiftCtx; t: PType; x, y: PNode): PNode =
   let lenCall = genBuiltin(c, mLengthSeq, "len", y)
-  lenCall.typ() = getSysType(c.g, x.info, tyInt)
+  lenCall.typ = getSysType(c.g, x.info, tyInt)
   var op = getSysMagic(c.g, x.info, "setLen", mSetLengthSeq)
   op = instantiateGeneric(c, op, t, t)
   result = newTree(nkCall, newSymNode(op, x.info), x, lenCall)
@@ -565,7 +545,7 @@ proc forallElements(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let counterIdx = body.len
   let i = declareCounter(c, body, toInt64(firstOrd(c.g.config, t)))
   let whileLoop = genWhileLoop(c, i, x)
-  let elemType = t.elementType
+  let elemType = t.lastSon
   let b = if c.kind == attachedTrace: y else: y.at(i, elemType)
   fillBody(c, elemType, whileLoop[1], x.at(i, elemType), b)
   if whileLoop[1].len > 0:
@@ -579,7 +559,7 @@ proc checkSelfAssignment(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       newTreeIT(nkAddr, c.info, makePtrType(c.fn, x.typ, c.idgen), x),
       newTreeIT(nkAddr, c.info, makePtrType(c.fn, y.typ, c.idgen), y)
       )
-  cond.typ() = getSysType(c.g, c.info, tyBool)
+  cond.typ = getSysType(c.g, c.info, tyBool)
   body.add genIf(c, cond, newTreeI(nkReturnStmt, c.info, newNodeI(nkEmpty, c.info)))
 
 proc fillSeqOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
@@ -676,7 +656,7 @@ proc fillStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 
 proc cyclicType*(g: ModuleGraph, t: PType): bool =
   case t.kind
-  of tyRef: result = types.canFormAcycle(g, t.elementType)
+  of tyRef: result = types.canFormAcycle(g, t.lastSon)
   of tyProc: result = t.callConv == ccClosure
   else: result = false
 
@@ -701,7 +681,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 
   ]#
   var actions = newNodeI(nkStmtList, c.info)
-  let elemType = t.elementType
+  let elemType = t.lastSon
 
   createTypeBoundOps(c.g, c.c, elemType, c.info, c.idgen)
   let isCyclic = c.g.config.selectedGC == gcOrc and types.canFormAcycle(c.g, elemType)
@@ -720,7 +700,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   if isFinal(elemType):
     addDestructorCall(c, elemType, actions, genDeref(tmp, nkDerefExpr))
     var alignOf = genBuiltin(c, mAlignOf, "alignof", newNodeIT(nkType, c.info, elemType))
-    alignOf.typ() = getSysType(c.g, c.info, tyInt)
+    alignOf.typ = getSysType(c.g, c.info, tyInt)
     actions.add callCodegenProc(c.g, "nimRawDispose", c.info, tmp, alignOf)
   else:
     addDestructorCall(c, elemType, newNodeI(nkStmtList, c.info), genDeref(tmp, nkDerefExpr))
@@ -730,7 +710,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   if isCyclic:
     if isFinal(elemType):
       let typInfo = genBuiltin(c, mGetTypeInfoV2, "getTypeInfoV2", newNodeIT(nkType, x.info, elemType))
-      typInfo.typ() = getSysType(c.g, c.info, tyPointer)
+      typInfo.typ = getSysType(c.g, c.info, tyPointer)
       cond = callCodegenProc(c.g, "nimDecRefIsLastCyclicStatic", c.info, tmp, typInfo)
     else:
       cond = callCodegenProc(c.g, "nimDecRefIsLastCyclicDyn", c.info, tmp)
@@ -738,7 +718,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     cond = callCodegenProc(c.g, "nimDecRefIsLastDyn", c.info, x)
   else:
     cond = callCodegenProc(c.g, "nimDecRefIsLast", c.info, x)
-  cond.typ() = getSysType(c.g, x.info, tyBool)
+  cond.typ = getSysType(c.g, x.info, tyBool)
 
   case c.kind
   of attachedSink:
@@ -765,7 +745,7 @@ proc atomicRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     if isCyclic:
       if isFinal(elemType):
         let typInfo = genBuiltin(c, mGetTypeInfoV2, "getTypeInfoV2", newNodeIT(nkType, x.info, elemType))
-        typInfo.typ() = getSysType(c.g, c.info, tyPointer)
+        typInfo.typ = getSysType(c.g, c.info, tyPointer)
         body.add callCodegenProc(c.g, "nimTraceRef", c.info, genAddrOf(x, c.idgen), typInfo, y)
       else:
         # If the ref is polymorphic we have to account for this
@@ -786,7 +766,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   ## Closures are really like refs except they always use a virtual destructor
   ## and we need to do the refcounting only on the ref field which we call 'xenv':
   let xenv = genBuiltin(c, mAccessEnv, "accessEnv", x)
-  xenv.typ() = getSysType(c.g, c.info, tyPointer)
+  xenv.typ = getSysType(c.g, c.info, tyPointer)
 
   let isCyclic = c.g.config.selectedGC == gcOrc
   let tmp =
@@ -802,7 +782,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     if isCyclic: "nimDecRefIsLastCyclicDyn"
     else: "nimDecRefIsLast"
   let cond = callCodegenProc(c.g, decRefProc, c.info, tmp)
-  cond.typ() = getSysType(c.g, x.info, tyBool)
+  cond.typ = getSysType(c.g, x.info, tyBool)
 
   case c.kind
   of attachedSink:
@@ -814,7 +794,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.add newAsgnStmt(x, y)
   of attachedAsgn:
     let yenv = genBuiltin(c, mAccessEnv, "accessEnv", y)
-    yenv.typ() = getSysType(c.g, c.info, tyPointer)
+    yenv.typ = getSysType(c.g, c.info, tyPointer)
     if isCyclic:
       body.add genIf(c, yenv, callCodegenProc(c.g, "nimIncRefCyclic", c.info, yenv, getCycleParam(c)))
       body.add newAsgnStmt(x, y)
@@ -826,7 +806,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.add newAsgnStmt(x, y)
   of attachedDup:
     let yenv = genBuiltin(c, mAccessEnv, "accessEnv", y)
-    yenv.typ() = getSysType(c.g, c.info, tyPointer)
+    yenv.typ = getSysType(c.g, c.info, tyPointer)
     if isCyclic:
       body.add newAsgnStmt(x, y)
       body.add genIf(c, yenv, callCodegenProc(c.g, "nimIncRefCyclic", c.info, yenv, getCycleParam(c)))
@@ -871,14 +851,14 @@ proc weakrefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   var actions = newNodeI(nkStmtList, c.info)
 
-  let elemType = t.skipModifier
+  let elemType = t.lastSon
   #fillBody(c, elemType, actions, genDeref(x), genDeref(y))
   #var disposeCall = genBuiltin(c, mDispose, "dispose", x)
 
   if isFinal(elemType):
     addDestructorCall(c, elemType, actions, genDeref(x, nkDerefExpr))
     var alignOf = genBuiltin(c, mAlignOf, "alignof", newNodeIT(nkType, c.info, elemType))
-    alignOf.typ() = getSysType(c.g, c.info, tyInt)
+    alignOf.typ = getSysType(c.g, c.info, tyInt)
     actions.add callCodegenProc(c.g, "nimRawDispose", c.info, x, alignOf)
   else:
     addDestructorCall(c, elemType, newNodeI(nkStmtList, c.info), genDeref(x, nkDerefExpr))
@@ -901,14 +881,14 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     # a big problem is that we don't know the environment's type here, so we
     # have to go through some indirection; we delegate this to the codegen:
     let call = newNodeI(nkCall, c.info, 2)
-    call.typ() = t
+    call.typ = t
     call[0] = newSymNode(createMagic(c.g, c.idgen, "deepCopy", mDeepCopy))
     call[1] = y
     body.add newAsgnStmt(x, call)
   elif (optOwnedRefs in c.g.config.globalOptions and
       optRefCheck in c.g.config.options) or c.g.config.selectedGC in {gcArc, gcAtomicArc, gcOrc}:
     let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
-    xx.typ() = getSysType(c.g, c.info, tyPointer)
+    xx.typ = getSysType(c.g, c.info, tyPointer)
     case c.kind
     of attachedSink:
       # we 'nil' y out afterwards so we *need* to take over its reference
@@ -917,13 +897,13 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.add newAsgnStmt(x, y)
     of attachedAsgn:
       let yy = genBuiltin(c, mAccessEnv, "accessEnv", y)
-      yy.typ() = getSysType(c.g, c.info, tyPointer)
+      yy.typ = getSysType(c.g, c.info, tyPointer)
       body.add genIf(c, yy, callCodegenProc(c.g, "nimIncRef", c.info, yy))
       body.add genIf(c, xx, callCodegenProc(c.g, "nimDecWeakRef", c.info, xx))
       body.add newAsgnStmt(x, y)
     of attachedDup:
       let yy = genBuiltin(c, mAccessEnv, "accessEnv", y)
-      yy.typ() = getSysType(c.g, c.info, tyPointer)
+      yy.typ = getSysType(c.g, c.info, tyPointer)
       body.add newAsgnStmt(x, y)
       body.add genIf(c, yy, callCodegenProc(c.g, "nimIncRef", c.info, yy))
     of attachedDestructor:
@@ -938,7 +918,7 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
 
 proc ownedClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xx = genBuiltin(c, mAccessEnv, "accessEnv", x)
-  xx.typ() = getSysType(c.g, c.info, tyPointer)
+  xx.typ = getSysType(c.g, c.info, tyPointer)
   var actions = newNodeI(nkStmtList, c.info)
   #discard addDestructorCall(c, elemType, newNodeI(nkStmtList, c.info), genDeref(xx))
   actions.add callCodegenProc(c.g, "nimDestroyAndDispose", c.info, xx)
@@ -1037,7 +1017,7 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
           fillBodyObjT(c, t, body, x, y)
   of tyDistinct:
     if not considerUserDefinedOp(c, t, body, x, y):
-      fillBody(c, t.elementType, body, x, y)
+      fillBody(c, t[0], body, x, y)
   of tyTuple:
     fillBodyTup(c, t, body, x, y)
   of tyVarargs, tyOpenArray:
@@ -1046,7 +1026,7 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     else:
       discard "cannot copy openArray"
 
-  of tyFromExpr, tyError, tyBuiltInTypeClass, tyUserTypeClass,
+  of tyFromExpr, tyProxy, tyBuiltInTypeClass, tyUserTypeClass,
      tyUserTypeClassInst, tyCompositeTypeClass, tyAnd, tyOr, tyNot, tyAnything,
      tyGenericParam, tyGenericBody, tyNil, tyUntyped, tyTyped,
      tyTypeDesc, tyGenericInvocation, tyForward, tyStatic:
@@ -1054,18 +1034,16 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     discard
   of tyOrdinal, tyRange, tyInferred,
      tyGenericInst, tyAlias, tySink:
-    fillBody(c, skipModifier(t), body, x, y)
+    fillBody(c, lastSon(t), body, x, y)
   of tyConcept, tyIterable: raiseAssert "unreachable"
 
 proc produceSymDistinctType(g: ModuleGraph; c: PContext; typ: PType;
                             kind: TTypeAttachedOp; info: TLineInfo;
                             idgen: IdGenerator): PSym =
   assert typ.kind == tyDistinct
-  let baseType = typ.elementType
+  let baseType = typ[0]
   if getAttachedOp(g, baseType, kind) == nil:
-    # TODO: fixme `isDistinct` is a fix for #23552; remove it after
-    # `-d:nimPreviewNonVarDestructor` becomes the default
-    discard produceSym(g, c, baseType, kind, info, idgen, isDistinct = true)
+    discard produceSym(g, c, baseType, kind, info, idgen)
   result = getAttachedOp(g, baseType, kind)
   setAttachedOp(g, idgen.module, typ, kind, result)
 
@@ -1104,7 +1082,7 @@ proc symDupPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttache
   incl result.flags, sfGeneratedOp
 
 proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false; isDistinct = false): PSym =
+              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false): PSym =
   if kind == attachedDup:
     return symDupPrototype(g, typ, owner, kind, info, idgen)
 
@@ -1115,7 +1093,7 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
                    idgen, result, info)
 
   if kind == attachedDestructor and g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
-     ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or (typ.kind in {tyRef, tyString, tySequence} and not isDistinct)):
+     ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or typ.kind in {tyRef, tyString, tySequence}):
     dest.typ = typ
   else:
     dest.typ = makeVarType(typ.owner, typ, idgen)
@@ -1152,24 +1130,24 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
 proc genTypeFieldCopy(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   let xx = genBuiltin(c, mAccessTypeField, "accessTypeField", x)
   let yy = genBuiltin(c, mAccessTypeField, "accessTypeField", y)
-  xx.typ() = getSysType(c.g, c.info, tyPointer)
-  yy.typ() = xx.typ
+  xx.typ = getSysType(c.g, c.info, tyPointer)
+  yy.typ = xx.typ
   body.add newAsgnStmt(xx, yy)
 
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator; isDistinct = false): PSym =
+              info: TLineInfo; idgen: IdGenerator): PSym =
   if typ.kind == tyDistinct:
     return produceSymDistinctType(g, c, typ, kind, info, idgen)
 
   result = getAttachedOp(g, typ, kind)
   if result == nil:
-    result = symPrototype(g, typ, typ.owner, kind, info, idgen, isDistinct = isDistinct)
+    result = symPrototype(g, typ, typ.owner, kind, info, idgen)
 
   var a = TLiftCtx(info: info, g: g, kind: kind, c: c, asgnForType: typ, idgen: idgen,
                    fn: result)
 
   let dest = if kind == attachedDup: result.ast[resultPos].sym else: result.typ.n[1].sym
-  let d = if result.typ.firstParamType.kind == tyVar: newDeref(newSymNode(dest)) else: newSymNode(dest)
+  let d = if result.typ[1].kind == tyVar: newDeref(newSymNode(dest)) else: newSymNode(dest)
   let src = case kind
             of {attachedDestructor, attachedWasMoved}: newNodeIT(nkSym, info, getSysType(g, info, tyPointer))
             of attachedDup: newSymNode(result.typ.n[1].sym)
@@ -1182,7 +1160,7 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
     ## compiler can use a combination of `=destroy` and memCopy for sink op
     dest.flags.incl sfCursor
     let op = getAttachedOp(g, typ, attachedDestructor)
-    result.ast[bodyPos].add newOpCall(a, op, if op.typ.firstParamType.kind == tyVar: d[0] else: d)
+    result.ast[bodyPos].add newOpCall(a, op, if op.typ[1].kind == tyVar: d[0] else: d)
     result.ast[bodyPos].add newAsgnStmt(d, src)
   else:
     var tk: TTypeKind
@@ -1201,12 +1179,7 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
         # bug #19205: Do not forget to also copy the hidden type field:
         genTypeFieldCopy(a, typ, result.ast[bodyPos], d, src)
 
-  if not a.canRaise:
-    incl result.flags, sfNeverRaises
-    result.ast[pragmasPos] = newNodeI(nkPragma, info)
-    result.ast[pragmasPos].add newTree(nkExprColonExpr,
-        newIdentNode(g.cache.getIdent("raises"),  info), newNodeI(nkBracket, info))
-
+  if not a.canRaise: incl result.flags, sfNeverRaises
   completePartialOp(g, idgen.module, typ, kind, result)
 
 
@@ -1266,7 +1239,7 @@ proc inst(g: ModuleGraph; c: PContext; t: PType; kind: TTypeAttachedOp; idgen: I
     else:
       localError(g.config, info, "unresolved generic parameter")
 
-proc isTrival*(s: PSym): bool {.inline.} =
+proc isTrival(s: PSym): bool {.inline.} =
   s == nil or (s.ast != nil and s.ast[bodyPos].len == 0)
 
 proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo;

compiler/liftlocals.nim

@@ -32,12 +32,12 @@ proc interestingVar(s: PSym): bool {.inline.} =
 proc lookupOrAdd(c: var Ctx; s: PSym; info: TLineInfo): PNode =
   let field = addUniqueField(c.objType, s, c.cache, c.idgen)
   var deref = newNodeI(nkHiddenDeref, info)
-  deref.typ() = c.objType
+  deref.typ = c.objType
   deref.add(newSymNode(c.partialParam, info))
   result = newNodeI(nkDotExpr, info)
   result.add(deref)
   result.add(newSymNode(field))
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc liftLocals(n: PNode; i: int; c: var Ctx) =
   let it = n[i]

compiler/lineinfos.nim

@@ -92,10 +92,8 @@ type
     warnStmtListLambda = "StmtListLambda",
     warnBareExcept = "BareExcept",
     warnImplicitDefaultValue = "ImplicitDefaultValue",
-    warnIgnoredSymbolInjection = "IgnoredSymbolInjection",
     warnStdPrefix = "StdPrefix"
     warnUser = "User",
-    warnGlobalVarConstructorTemporary = "GlobalVarConstructorTemporary",
     # hints
     hintSuccess = "Success", hintSuccessX = "SuccessX",
     hintCC = "CC",
@@ -198,10 +196,8 @@ const
     warnStmtListLambda: "statement list expression assumed to be anonymous proc; this is deprecated, use `do (): ...` or `proc () = ...` instead",
     warnBareExcept: "$1",
     warnImplicitDefaultValue: "$1",
-    warnIgnoredSymbolInjection: "$1",
     warnStdPrefix: "$1 needs the 'std' prefix",
     warnUser: "$1",
-    warnGlobalVarConstructorTemporary: "global variable '$1' initialization requires a temporary variable",
     hintSuccess: "operation successful: $#",
     # keep in sync with `testament.isSuccess`
     hintSuccessX: "$build\n$loc lines; ${sec}s; $mem; proj: $project; out: $output",
@@ -268,7 +264,6 @@ const
   NotesVerbosity* = computeNotesVerbosity()
   errXMustBeCompileTime* = "'$1' can only be used in compile-time context"
   errArgsNeedRunOption* = "arguments can only be given if the '--run' option is selected"
-  errFloatToString* = "cannot convert '$1' to '$2'"
 
 type
   TFileInfo* = object

compiler/linter.nim

@@ -12,7 +12,7 @@
 import std/strutils
 from std/sugar import dup
 
-import options, ast, msgs, idents, lineinfos, wordrecg, astmsgs, semdata, packages, modulegraphs
+import options, ast, msgs, idents, lineinfos, wordrecg, astmsgs, semdata, packages
 export packages
 
 const
@@ -97,7 +97,7 @@ template styleCheckDef*(ctx: PContext; info: TLineInfo; sym: PSym; k: TSymKind)
   if optStyleCheck in ctx.config.options and # ignore if styleChecks are off
      {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # check only if hint/error is enabled
      hintName in ctx.config.notes and # ignore if name checks are not requested
-     ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)) and # ignore foreign packages
+     ctx.config.belongsToProjectPackage(sym) and # ignore foreign packages
      optStyleUsages notin ctx.config.globalOptions and # ignore if requested to only check name usage
      sym.kind != skResult and # ignore `result`
      sym.kind != skTemp and # ignore temporary variables created by the compiler
@@ -138,7 +138,7 @@ template styleCheckUse*(ctx: PContext; info: TLineInfo; sym: PSym) =
   ## Check symbol uses match their definition's style.
   if {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
      hintName in ctx.config.notes and # ignore if name checks are not requested
-     ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)) and # ignore foreign packages
+     ctx.config.belongsToProjectPackage(sym) and # ignore foreign packages
      sym.kind != skTemp and # ignore temporary variables created by the compiler
      sym.name.s[0] in Letters and # ignore operators TODO: what about unicode symbols???
      sfAnon notin sym.flags: # ignore temporary variables created by the compiler
@@ -154,5 +154,5 @@ template checkPragmaUse*(ctx: PContext; info: TLineInfo; w: TSpecialWord; pragma
   ## Note: This only applies to builtin pragmas, not user pragmas.
   if {optStyleHint, optStyleError} * ctx.config.globalOptions != {} and # ignore if styleChecks are off
      hintName in ctx.config.notes and # ignore if name checks are not requested
-     ctx.config.belongsToProjectPackageMaybeNil(getModule(ctx.graph, info.fileIndex)): # ignore foreign packages
+     (sym != nil and ctx.config.belongsToProjectPackage(sym)): # ignore foreign packages
     checkPragmaUseImpl(ctx.config, info, w, pragmaName)

compiler/llstream.nim

@@ -68,7 +68,6 @@ when not declared(readLineFromStdin):
   # fallback implementation:
   proc readLineFromStdin(prompt: string, line: var string): bool =
     stdout.write(prompt)
-    stdout.flushFile()
     result = readLine(stdin, line)
     if not result:
       stdout.write("\n")

compiler/lookups.nim

@@ -50,7 +50,7 @@ proc considerQuotedIdent*(c: PContext; n: PNode, origin: PNode = nil): PIdent =
         case x.kind
         of nkIdent: id.add(x.ident.s)
         of nkSym: id.add(x.sym.name.s)
-        of nkSymChoices, nkOpenSym:
+        of nkSymChoices:
           if x[0].kind == nkSym:
             id.add(x[0].sym.name.s)
           else:
@@ -63,8 +63,6 @@ proc considerQuotedIdent*(c: PContext; n: PNode, origin: PNode = nil): PIdent =
       result = n[0].sym.name
     else:
       handleError(n, origin)
-  of nkOpenSym:
-    result = considerQuotedIdent(c, n[0], origin)
   else:
     handleError(n, origin)
 
@@ -139,7 +137,7 @@ proc nextIdentIter(ti: var ModuleIter; marked: var IntSet; im: ImportedModule;
         return result
 
 iterator symbols(im: ImportedModule; marked: var IntSet; name: PIdent; g: ModuleGraph): PSym =
-  var ti: ModuleIter = default(ModuleIter)
+  var ti: ModuleIter
   var candidate = initIdentIter(ti, marked, im, name, g)
   while candidate != nil:
     yield candidate
@@ -152,7 +150,7 @@ iterator importedItems*(c: PContext; name: PIdent): PSym =
       yield s
 
 proc allPureEnumFields(c: PContext; name: PIdent): seq[PSym] =
-  var ti: TIdentIter = default(TIdentIter)
+  var ti: TIdentIter
   result = @[]
   var res = initIdentIter(ti, c.pureEnumFields, name)
   while res != nil:
@@ -224,7 +222,7 @@ proc debugScopes*(c: PContext; limit=0, max = int.high) {.deprecated.} =
 proc searchInScopesAllCandidatesFilterBy*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
   result = @[]
   for scope in allScopes(c.currentScope):
-    var ti: TIdentIter = default(TIdentIter)
+    var ti: TIdentIter
     var candidate = initIdentIter(ti, scope.symbols, s)
     while candidate != nil:
       if candidate.kind in filter:
@@ -242,7 +240,7 @@ proc searchInScopesFilterBy*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSy
   result = @[]
   block outer:
     for scope in allScopes(c.currentScope):
-      var ti: TIdentIter = default(TIdentIter)
+      var ti: TIdentIter
       var candidate = initIdentIter(ti, scope.symbols, s)
       while candidate != nil:
         if candidate.kind in filter:
@@ -258,23 +256,11 @@ proc searchInScopesFilterBy*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSy
         if s.kind in filter:
           result.add s
 
-proc cmpScopes*(ctx: PContext, s: PSym): int =
-  # Do not return a negative number
-  if s.originatingModule == ctx.module:
-    result = 2
-    var owner = s
-    while true:
-      owner = owner.skipGenericOwner
-      if owner.kind == skModule: break
-      inc result
-  else:
-    result = 1
-
 proc isAmbiguous*(c: PContext, s: PIdent, filter: TSymKinds, sym: var PSym): bool =
   result = false
   block outer:
     for scope in allScopes(c.currentScope):
-      var ti: TIdentIter = default(TIdentIter)
+      var ti: TIdentIter
       var candidate = initIdentIter(ti, scope.symbols, s)
       var scopeHasCandidate = false
       while candidate != nil:
@@ -305,16 +291,8 @@ proc isAmbiguous*(c: PContext, s: PIdent, filter: TSymKinds, sym: var PSym): boo
     # imports had a candidate but wasn't ambiguous
     return false
 
-proc errorSym*(c: PContext, ident: PIdent, info: TLineInfo): PSym =
-  ## creates an error symbol to avoid cascading errors (for IDE support)
-  result = newSym(skError, ident, c.idgen, getCurrOwner(c), info, {})
-  result.typ = errorType(c)
-  incl(result.flags, sfDiscardable)
-  # pretend it's from the top level scope to prevent cascading errors:
-  if c.config.cmd != cmdInteractive and c.compilesContextId == 0:
-    c.moduleScope.addSym(result)
-
 proc errorSym*(c: PContext, n: PNode): PSym =
+  ## creates an error symbol to avoid cascading errors (for IDE support)
   var m = n
   # ensure that 'considerQuotedIdent' can't fail:
   if m.kind == nkDotExpr: m = m[1]
@@ -322,7 +300,12 @@ proc errorSym*(c: PContext, n: PNode): PSym =
       considerQuotedIdent(c, m)
     else:
       getIdent(c.cache, "err:" & renderTree(m))
-  result = errorSym(c, ident, n.info)
+  result = newSym(skError, ident, c.idgen, getCurrOwner(c), n.info, {})
+  result.typ = errorType(c)
+  incl(result.flags, sfDiscardable)
+  # pretend it's from the top level scope to prevent cascading errors:
+  if c.config.cmd != cmdInteractive and c.compilesContextId == 0:
+    c.moduleScope.addSym(result)
 
 type
   TOverloadIterMode* = enum
@@ -349,7 +332,7 @@ proc getSymRepr*(conf: ConfigRef; s: PSym, getDeclarationPath = true): string =
 
 proc ensureNoMissingOrUnusedSymbols(c: PContext; scope: PScope) =
   # check if all symbols have been used and defined:
-  var it: TTabIter = default(TTabIter)
+  var it: TTabIter
   var s = initTabIter(it, scope.symbols)
   var missingImpls = 0
   var unusedSyms: seq[tuple[sym: PSym, key: string]] = @[]
@@ -504,7 +487,7 @@ proc mustFixSpelling(c: PContext): bool {.inline.} =
   result = c.config.spellSuggestMax != 0 and c.compilesContextId == 0
     # don't slowdown inside compiles()
 
-proc fixSpelling(c: PContext, ident: PIdent, result: var string) =
+proc fixSpelling(c: PContext, n: PNode, ident: PIdent, result: var string) =
   ## when we cannot find the identifier, suggest nearby spellings
   var list = initHeapQueue[SpellCandidate]()
   let name0 = ident.s.nimIdentNormalize
@@ -560,47 +543,33 @@ proc errorUseQualifier(c: PContext; info: TLineInfo; s: PSym; amb: var bool): PS
     amb = false
 
 proc errorUseQualifier*(c: PContext; info: TLineInfo; s: PSym) =
-  var amb: bool = false
+  var amb: bool
   discard errorUseQualifier(c, info, s, amb)
 
-proc ambiguousIdentifierMsg*(candidates: seq[PSym], prefix = "use one of", indent = 0): string =
-  result = ""
-  for i in 0 ..< indent:
-    result.add(' ')
-  result.add "ambiguous identifier: '" & candidates[0].name.s & "'"
+proc errorUseQualifier(c: PContext; info: TLineInfo; candidates: seq[PSym]; prefix = "use one of") =
+  var err = "ambiguous identifier: '" & candidates[0].name.s & "'"
   var i = 0
   for candidate in candidates:
-    if i == 0: result.add " -- $1 the following:\n" % prefix
-    else: result.add "\n"
-    for i in 0 ..< indent:
-      result.add(' ')
-    result.add "  " & candidate.owner.name.s & "." & candidate.name.s
-    result.add ": " & typeToString(candidate.typ)
+    if i == 0: err.add " -- $1 the following:\n" % prefix
+    else: err.add "\n"
+    err.add "  " & candidate.owner.name.s & "." & candidate.name.s
+    err.add ": " & typeToString(candidate.typ)
     inc i
+  localError(c.config, info, errGenerated, err)
 
-proc errorUseQualifier*(c: PContext; info: TLineInfo; candidates: seq[PSym]) =
-  localError(c.config, info, errGenerated, ambiguousIdentifierMsg(candidates))
-
-proc ambiguousIdentifierMsg*(choices: PNode, indent = 0): string =
+proc errorUseQualifier*(c: PContext; info:TLineInfo; choices: PNode) =
   var candidates = newSeq[PSym](choices.len)
   let prefix = if choices[0].typ.kind != tyProc: "use one of" else: "you need a helper proc to disambiguate"
   for i, n in choices:
     candidates[i] = n.sym
-  result = ambiguousIdentifierMsg(candidates, prefix, indent)
-
-proc errorUseQualifier*(c: PContext; info:TLineInfo; choices: PNode) =
-  localError(c.config, info, errGenerated, ambiguousIdentifierMsg(choices))
+  errorUseQualifier(c, info, candidates, prefix)
 
 proc errorUndeclaredIdentifier*(c: PContext; info: TLineInfo; name: string, extra = "") =
   var err: string
   if name == "_":
     err = "the special identifier '_' is ignored in declarations and cannot be used"
   else:
-    err = "undeclared identifier: '" & name & "'"
-    if "`gensym" in name:
-      err.add "; if declared in a template, this identifier may be inconsistently marked inject or gensym"
-    if extra.len != 0:
-      err.add extra
+    err = "undeclared identifier: '" & name & "'" & extra
     if c.recursiveDep.len > 0:
       err.add "\nThis might be caused by a recursive module dependency:\n"
       err.add c.recursiveDep
@@ -608,11 +577,11 @@ proc errorUndeclaredIdentifier*(c: PContext; info: TLineInfo; name: string, extr
       c.recursiveDep = ""
   localError(c.config, info, errGenerated, err)
 
-proc errorUndeclaredIdentifierHint*(c: PContext; ident: PIdent; info: TLineInfo): PSym =
+proc errorUndeclaredIdentifierHint*(c: PContext; n: PNode, ident: PIdent): PSym =
   var extra = ""
-  if c.mustFixSpelling: fixSpelling(c, ident, extra)
-  errorUndeclaredIdentifier(c, info, ident.s, extra)
-  result = errorSym(c, ident, info)
+  if c.mustFixSpelling: fixSpelling(c, n, ident, extra)
+  errorUndeclaredIdentifier(c, n.info, ident.s, extra)
+  result = errorSym(c, n)
 
 proc lookUp*(c: PContext, n: PNode): PSym =
   # Looks up a symbol. Generates an error in case of nil.
@@ -620,13 +589,13 @@ proc lookUp*(c: PContext, n: PNode): PSym =
   case n.kind
   of nkIdent:
     result = searchInScopes(c, n.ident, amb)
-    if result == nil: result = errorUndeclaredIdentifierHint(c, n.ident, n.info)
+    if result == nil: result = errorUndeclaredIdentifierHint(c, n, n.ident)
   of nkSym:
     result = n.sym
   of nkAccQuoted:
     var ident = considerQuotedIdent(c, n)
     result = searchInScopes(c, ident, amb)
-    if result == nil: result = errorUndeclaredIdentifierHint(c, ident, n.info)
+    if result == nil: result = errorUndeclaredIdentifierHint(c, n, ident)
   else:
     internalError(c.config, n.info, "lookUp")
     return nil
@@ -640,30 +609,16 @@ type
   TLookupFlag* = enum
     checkAmbiguity, checkUndeclared, checkModule, checkPureEnumFields
 
-const allExceptModule = {low(TSymKind)..high(TSymKind)} - {skModule, skPackage}
-
-proc lookUpCandidates*(c: PContext, ident: PIdent, filter: set[TSymKind],
-                       includePureEnum = false): seq[PSym] =
-  result = searchInScopesFilterBy(c, ident, filter)
-  if skEnumField in filter and (result.len == 0 or includePureEnum):
-    result.add allPureEnumFields(c, ident)
-
 proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
+  const allExceptModule = {low(TSymKind)..high(TSymKind)} - {skModule, skPackage}
   case n.kind
   of nkIdent, nkAccQuoted:
     var amb = false
     var ident = considerQuotedIdent(c, n)
     if checkModule in flags:
       result = searchInScopes(c, ident, amb)
-      if result == nil:
-        let candidates = allPureEnumFields(c, ident)
-        if candidates.len > 0:
-          result = candidates[0]
-          amb = candidates.len > 1
-          if amb and checkAmbiguity in flags:
-            errorUseQualifier(c, n.info, candidates)
     else:
-      let candidates = lookUpCandidates(c, ident, allExceptModule)
+      let candidates = searchInScopesFilterBy(c, ident, allExceptModule)
       if candidates.len > 0:
         result = candidates[0]
         amb = candidates.len > 1
@@ -671,47 +626,46 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
           errorUseQualifier(c, n.info, candidates)
       else:
         result = nil
+    if result == nil:
+      let candidates = allPureEnumFields(c, ident)
+      if candidates.len > 0:
+        result = candidates[0]
+        amb = candidates.len > 1
+        if amb and checkAmbiguity in flags:
+          errorUseQualifier(c, n.info, candidates)
+
     if result == nil and checkUndeclared in flags:
-      result = errorUndeclaredIdentifierHint(c, ident, n.info)
+      result = errorUndeclaredIdentifierHint(c, n, ident)
     elif checkAmbiguity in flags and result != nil and amb:
       result = errorUseQualifier(c, n.info, result, amb)
     c.isAmbiguous = amb
   of nkSym:
     result = n.sym
-  of nkOpenSym:
-    result = qualifiedLookUp(c, n[0], flags)
   of nkDotExpr:
     result = nil
     var m = qualifiedLookUp(c, n[0], (flags * {checkUndeclared}) + {checkModule})
     if m != nil and m.kind == skModule:
       var ident: PIdent = nil
-      if n[1].kind == nkAccQuoted:
+      if n[1].kind == nkIdent:
+        ident = n[1].ident
+      elif n[1].kind == nkAccQuoted:
         ident = considerQuotedIdent(c, n[1])
-      else:
-        # this includes sym and symchoice nodes, but since we are looking in
-        # a module, it shouldn't matter what was captured
-        ident = n[1].getPIdent
       if ident != nil:
         if m == c.module:
-          var ti: TIdentIter = default(TIdentIter)
-          result = initIdentIter(ti, c.topLevelScope.symbols, ident)
-          if result != nil and nextIdentIter(ti, c.topLevelScope.symbols) != nil:
-            # another symbol exists with same name
-            c.isAmbiguous = true
+          result = strTableGet(c.topLevelScope.symbols, ident)
         else:
-          var amb: bool = false
           if c.importModuleLookup.getOrDefault(m.name.id).len > 1:
+            var amb: bool
             result = errorUseQualifier(c, n.info, m, amb)
           else:
-            result = someSymAmb(c.graph, m, ident, amb)
-            if amb: c.isAmbiguous = true
+            result = someSym(c.graph, m, ident)
         if result == nil and checkUndeclared in flags:
-          result = errorUndeclaredIdentifierHint(c, ident, n[1].info)
+          result = errorUndeclaredIdentifierHint(c, n[1], ident)
       elif n[1].kind == nkSym:
         result = n[1].sym
         if result.owner != nil and result.owner != m and checkUndeclared in flags:
           # dotExpr in templates can end up here
-          result = errorUndeclaredIdentifierHint(c, result.name, n[1].info)
+          result = errorUndeclaredIdentifierHint(c, n[1], considerQuotedIdent(c, n[1]))
       elif checkUndeclared in flags and
            n[1].kind notin {nkOpenSymChoice, nkClosedSymChoice}:
         localError(c.config, n[1].info, "identifier expected, but got: " &
@@ -723,10 +677,6 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
     if result != nil and result.kind == skStub: loadStub(result)
 
 proc initOverloadIter*(o: var TOverloadIter, c: PContext, n: PNode): PSym =
-  if n.kind == nkOpenSym:
-    # maybe the logic in semexprs should be mirrored here instead
-    # for now it only seems this is called for `pickSym` in `getTypeIdent` 
-    return initOverloadIter(o, c, n[0])
   o.importIdx = -1
   o.marked = initIntSet()
   case n.kind

compiler/lowerings.nim

@@ -19,7 +19,7 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 proc newDeref*(n: PNode): PNode {.inline.} =
-  result = newNodeIT(nkHiddenDeref, n.info, n.typ.elementType)
+  result = newNodeIT(nkHiddenDeref, n.info, n.typ[0])
   result.add n
 
 proc newTupleAccess*(g: ModuleGraph; tup: PNode, i: int): PNode =
@@ -174,12 +174,12 @@ proc rawIndirectAccess*(a: PNode; field: PSym; info: TLineInfo): PNode =
   # returns a[].field as a node
   assert field.kind == skField
   var deref = newNodeI(nkHiddenDeref, info)
-  deref.typ() = a.typ.skipTypes(abstractInst)[0]
+  deref.typ = a.typ.skipTypes(abstractInst)[0]
   deref.add a
   result = newNodeI(nkDotExpr, info)
   result.add deref
   result.add newSymNode(field)
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc rawDirectAccess*(obj, field: PSym): PNode =
   # returns a.field as a node
@@ -187,7 +187,7 @@ proc rawDirectAccess*(obj, field: PSym): PNode =
   result = newNodeI(nkDotExpr, field.info)
   result.add newSymNode(obj)
   result.add newSymNode(field)
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc lookupInRecord(n: PNode, id: ItemId): PSym =
   result = nil
@@ -250,19 +250,19 @@ proc newDotExpr*(obj, b: PSym): PNode =
   assert field != nil, b.name.s
   result.add newSymNode(obj)
   result.add newSymNode(field)
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc indirectAccess*(a: PNode, b: ItemId, info: TLineInfo): PNode =
   # returns a[].b as a node
   var deref = newNodeI(nkHiddenDeref, info)
-  deref.typ() = a.typ.skipTypes(abstractInst).elementType
+  deref.typ = a.typ.skipTypes(abstractInst)[0]
   var t = deref.typ.skipTypes(abstractInst)
   var field: PSym
   while true:
     assert t.kind == tyObject
     field = lookupInRecord(t.n, b)
     if field != nil: break
-    t = t.baseClass
+    t = t[0]
     if t == nil: break
     t = t.skipTypes(skipPtrs)
   #if field == nil:
@@ -273,12 +273,12 @@ proc indirectAccess*(a: PNode, b: ItemId, info: TLineInfo): PNode =
   result = newNodeI(nkDotExpr, info)
   result.add deref
   result.add newSymNode(field)
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc indirectAccess*(a: PNode, b: string, info: TLineInfo; cache: IdentCache): PNode =
   # returns a[].b as a node
   var deref = newNodeI(nkHiddenDeref, info)
-  deref.typ() = a.typ.skipTypes(abstractInst).elementType
+  deref.typ = a.typ.skipTypes(abstractInst)[0]
   var t = deref.typ.skipTypes(abstractInst)
   var field: PSym
   let bb = getIdent(cache, b)
@@ -286,7 +286,7 @@ proc indirectAccess*(a: PNode, b: string, info: TLineInfo; cache: IdentCache): P
     assert t.kind == tyObject
     field = getSymFromList(t.n, bb)
     if field != nil: break
-    t = t.baseClass
+    t = t[0]
     if t == nil: break
     t = t.skipTypes(skipPtrs)
   #if field == nil:
@@ -297,7 +297,7 @@ proc indirectAccess*(a: PNode, b: string, info: TLineInfo; cache: IdentCache): P
   result = newNodeI(nkDotExpr, info)
   result.add deref
   result.add newSymNode(field)
-  result.typ() = field.typ
+  result.typ = field.typ
 
 proc getFieldFromObj*(t: PType; v: PSym): PSym =
   assert v.kind != skField
@@ -306,7 +306,7 @@ proc getFieldFromObj*(t: PType; v: PSym): PSym =
     assert t.kind == tyObject
     result = lookupInRecord(t.n, v.itemId)
     if result != nil: break
-    t = t.baseClass
+    t = t[0]
     if t == nil: break
     t = t.skipTypes(skipPtrs)
 
@@ -320,12 +320,12 @@ proc indirectAccess*(a, b: PSym, info: TLineInfo): PNode =
 proc genAddrOf*(n: PNode; idgen: IdGenerator; typeKind = tyPtr): PNode =
   result = newNodeI(nkAddr, n.info, 1)
   result[0] = n
-  result.typ() = newType(typeKind, idgen, n.typ.owner)
+  result.typ = newType(typeKind, idgen, n.typ.owner)
   result.typ.rawAddSon(n.typ)
 
 proc genDeref*(n: PNode; k = nkHiddenDeref): PNode =
   result = newNodeIT(k, n.info,
-                     n.typ.skipTypes(abstractInst).elementType)
+                     n.typ.skipTypes(abstractInst)[0])
   result.add n
 
 proc callCodegenProc*(g: ModuleGraph; name: string;
@@ -344,18 +344,18 @@ proc callCodegenProc*(g: ModuleGraph; name: string;
     if optionalArgs != nil:
       for i in 1..<optionalArgs.len-2:
         result.add optionalArgs[i]
-    result.typ() = sym.typ.returnType
+    result.typ = sym.typ[0]
 
 proc newIntLit*(g: ModuleGraph; info: TLineInfo; value: BiggestInt): PNode =
   result = nkIntLit.newIntNode(value)
-  result.typ() = getSysType(g, info, tyInt)
+  result.typ = getSysType(g, info, tyInt)
 
 proc genHigh*(g: ModuleGraph; n: PNode): PNode =
   if skipTypes(n.typ, abstractVar).kind == tyArray:
     result = newIntLit(g, n.info, toInt64(lastOrd(g.config, skipTypes(n.typ, abstractVar))))
   else:
     result = newNodeI(nkCall, n.info, 2)
-    result.typ() = getSysType(g, n.info, tyInt)
+    result.typ = getSysType(g, n.info, tyInt)
     result[0] = newSymNode(getSysMagic(g, n.info, "high", mHigh))
     result[1] = n
 
@@ -364,7 +364,7 @@ proc genLen*(g: ModuleGraph; n: PNode): PNode =
     result = newIntLit(g, n.info, toInt64(lastOrd(g.config, skipTypes(n.typ, abstractVar)) + 1))
   else:
     result = newNodeI(nkCall, n.info, 2)
-    result.typ() = getSysType(g, n.info, tyInt)
+    result.typ = getSysType(g, n.info, tyInt)
     result[0] = newSymNode(getSysMagic(g, n.info, "len", mLengthSeq))
     result[1] = n
 

compiler/magicsys.nim

@@ -35,7 +35,7 @@ proc getSysMagic*(g: ModuleGraph; info: TLineInfo; name: string, m: TMagic): PSy
   for r in systemModuleSyms(g, id):
     if r.magic == m:
       # prefer the tyInt variant:
-      if r.typ.returnType != nil and r.typ.returnType.kind == tyInt: return r
+      if r.typ[0] != nil and r.typ[0].kind == tyInt: return r
       result = r
   if result != nil: return result
   localError(g.config, info, "system module needs: " & name)
@@ -166,4 +166,4 @@ proc makeAddr*(n: PNode; idgen: IdGenerator): PNode =
     result = n
   else:
     result = newTree(nkHiddenAddr, n)
-    result.typ() = makePtrType(n.typ, idgen)
+    result.typ = makePtrType(n.typ, idgen)

compiler/main.nim

@@ -22,6 +22,8 @@ import
   modules,
   modulegraphs, lineinfos, pathutils, vmprofiler
 
+# ensure NIR compiles:
+import nir / nir
 
 when defined(nimPreviewSlimSystem):
   import std/[syncio, assertions]
@@ -46,6 +48,9 @@ proc writeDepsFile(g: ModuleGraph) =
       f.writeLine(toFullPath(g.config, k))
   f.close()
 
+proc writeNinjaFile(g: ModuleGraph) =
+  discard "to implement"
+
 proc writeCMakeDepsFile(conf: ConfigRef) =
   ## write a list of C files for build systems like CMake.
   ## only updated when the C file list changes.
@@ -150,12 +155,32 @@ proc commandCompileToC(graph: ModuleGraph) =
     extccomp.callCCompiler(conf)
     # for now we do not support writing out a .json file with the build instructions when HCR is on
     if not conf.hcrOn:
-      extccomp.writeJsonBuildInstructions(conf, graph.cachedFiles)
+      extccomp.writeJsonBuildInstructions(conf)
     if optGenScript in graph.config.globalOptions:
       writeDepsFile(graph)
     if optGenCDeps in graph.config.globalOptions:
       writeCMakeDepsFile(conf)
 
+proc commandCompileToNir(graph: ModuleGraph) =
+  let conf = graph.config
+  extccomp.initVars(conf)
+  if conf.symbolFiles == disabledSf:
+    if {optRun, optForceFullMake} * conf.globalOptions == {optRun}:
+      if not changeDetectedViaJsonBuildInstructions(conf, conf.jsonBuildInstructionsFile):
+        # nothing changed
+        graph.config.notes = graph.config.mainPackageNotes
+        return
+
+  if not extccomp.ccHasSaneOverflow(conf):
+    conf.symbols.defineSymbol("nimEmulateOverflowChecks")
+
+  if conf.symbolFiles == disabledSf:
+    setPipeLinePass(graph, NirPass)
+  else:
+    setPipeLinePass(graph, SemPass)
+  compilePipelineProject(graph)
+  writeNinjaFile(graph)
+
 proc commandJsonScript(graph: ModuleGraph) =
   extccomp.runJsonBuildInstructions(graph.config, graph.config.jsonBuildInstructionsFile)
 
@@ -172,13 +197,16 @@ proc commandCompileToJS(graph: ModuleGraph) =
     if optGenScript in conf.globalOptions:
       writeDepsFile(graph)
 
-proc commandInteractive(graph: ModuleGraph) =
+proc commandInteractive(graph: ModuleGraph; useNir: bool) =
   graph.config.setErrorMaxHighMaybe
   initDefines(graph.config.symbols)
-  defineSymbol(graph.config.symbols, "nimscript")
+  if useNir:
+    defineSymbol(graph.config.symbols, "noSignalHandler")
+  else:
+    defineSymbol(graph.config.symbols, "nimscript")
   # note: seems redundant with -d:nimHasLibFFI
   when hasFFI: defineSymbol(graph.config.symbols, "nimffi")
-  setPipeLinePass(graph, InterpreterPass)
+  setPipeLinePass(graph, if useNir: NirReplPass else: InterpreterPass)
   compilePipelineSystemModule(graph)
   if graph.config.commandArgs.len > 0:
     discard graph.compilePipelineModule(fileInfoIdx(graph.config, graph.config.projectFull), {})
@@ -194,7 +222,7 @@ proc commandScan(cache: IdentCache, config: ConfigRef) =
   var stream = llStreamOpen(f, fmRead)
   if stream != nil:
     var
-      L: Lexer = default(Lexer)
+      L: Lexer
       tok: Token = default(Token)
     openLexer(L, f, stream, cache, config)
     while true:
@@ -265,6 +293,8 @@ proc mainCommand*(graph: ModuleGraph) =
         # and it has added this define implictly, so we must undo that here.
         # A better solution might be to fix system.nim
         undefSymbol(conf.symbols, "useNimRtl")
+    of backendNir:
+      if conf.exc == excNone: conf.exc = excGoto
     of backendInvalid: raiseAssert "unreachable"
 
   proc compileToBackend() =
@@ -275,6 +305,7 @@ proc mainCommand*(graph: ModuleGraph) =
     of backendCpp: commandCompileToC(graph)
     of backendObjc: commandCompileToC(graph)
     of backendJs: commandCompileToJS(graph)
+    of backendNir: commandCompileToNir(graph)
     of backendInvalid: raiseAssert "unreachable"
 
   template docLikeCmd(body) =
@@ -295,8 +326,7 @@ proc mainCommand*(graph: ModuleGraph) =
     # so by default should not end up in $PWD nor in $projectPath.
     var ret = if optUseNimcache in conf.globalOptions: getNimcacheDir(conf)
               else: conf.projectPath
-    if not ret.string.isAbsolute: # `AbsoluteDir` is not a real guarantee
-      rawMessage(conf, errCannotOpenFile, ret.string & "/")
+    doAssert ret.string.isAbsolute # `AbsoluteDir` is not a real guarantee
     if conf.cmd in cmdDocLike + {cmdRst2html, cmdRst2tex, cmdMd2html, cmdMd2tex}:
       ret = ret / htmldocsDir
     conf.outDir = ret
@@ -413,7 +443,7 @@ proc mainCommand*(graph: ModuleGraph) =
     wantMainModule(conf)
     commandView(graph)
     #msgWriteln(conf, "Beware: Indentation tokens depend on the parser's state!")
-  of cmdInteractive: commandInteractive(graph)
+  of cmdInteractive: commandInteractive(graph, isDefined(conf, "nir"))
   of cmdNimscript:
     if conf.projectIsCmd or conf.projectIsStdin: discard
     elif not fileExists(conf.projectFull):

compiler/mangleutils.nim

@@ -1,59 +0,0 @@
-import std/strutils
-import ast, modulegraphs
-
-proc mangle*(name: string): string =
-  result = newStringOfCap(name.len)
-  var start = 0
-  if name[0] in Digits:
-    result.add("X" & name[0])
-    start = 1
-  var requiresUnderscore = false
-  template special(x) =
-    result.add x
-    requiresUnderscore = true
-  for i in start..<name.len:
-    let c = name[i]
-    case c
-    of 'a'..'z', '0'..'9', 'A'..'Z':
-      result.add(c)
-    of '_':
-      # we generate names like 'foo_9' for scope disambiguations and so
-      # disallow this here:
-      if i > 0 and i < name.len-1 and name[i+1] in Digits:
-        discard
-      else:
-        result.add(c)
-    of '$': special "dollar"
-    of '%': special "percent"
-    of '&': special "amp"
-    of '^': special "roof"
-    of '!': special "emark"
-    of '?': special "qmark"
-    of '*': special "star"
-    of '+': special "plus"
-    of '-': special "minus"
-    of '/': special "slash"
-    of '\\': special "backslash"
-    of '=': special "eq"
-    of '<': special "lt"
-    of '>': special "gt"
-    of '~': special "tilde"
-    of ':': special "colon"
-    of '.': special "dot"
-    of '@': special "at"
-    of '|': special "bar"
-    else:
-      result.add("X" & toHex(ord(c), 2))
-      requiresUnderscore = true
-  if requiresUnderscore:
-    result.add "_"
-
-proc mangleParamExt*(s: PSym): string =
-  result = "_p"
-  result.addInt s.position
-
-proc mangleProcNameExt*(graph: ModuleGraph, s: PSym): string =
-  result = "__"
-  result.add graph.ifaces[s.itemId.module].uniqueName
-  result.add "_u"
-  result.addInt s.itemId.item # s.disamb #

compiler/modulegraphs.nim

@@ -11,9 +11,9 @@
 ## represents a complete Nim project. Single modules can either be kept in RAM
 ## or stored in a rod-file.
 
-import std/[intsets, tables, hashes, strtabs, algorithm, os, strutils, parseutils]
+import std/[intsets, tables, hashes]
 import ../dist/checksums/src/checksums/md5
-import ast, astalgo, options, lineinfos,idents, btrees, ropes, msgs, pathutils, packages, suggestsymdb
+import ast, astalgo, options, lineinfos,idents, btrees, ropes, msgs, pathutils, packages
 import ic / [packed_ast, ic]
 
 
@@ -55,6 +55,11 @@ type
     concreteTypes*: seq[FullId]
     inst*: PInstantiation
 
+  SymInfoPair* = object
+    sym*: PSym
+    info*: TLineInfo
+    isDecl*: bool
+
   PipelinePass* = enum
     NonePass
     SemPass
@@ -62,6 +67,8 @@ type
     CgenPass
     EvalPass
     InterpreterPass
+    NirPass
+    NirReplPass
     GenDependPass
     Docgen2TexPass
     Docgen2JsonPass
@@ -88,7 +95,6 @@ type
     suggestMode*: bool # whether we are in nimsuggest mode or not.
     invalidTransitiveClosure: bool
     interactive*: bool
-    withinSystem*: bool # in system.nim or a module imported by system.nim
     inclToMod*: Table[FileIndex, FileIndex] # mapping of include file to the
                                             # first module that included it
     importStack*: seq[FileIndex]  # The current import stack. Used for detecting recursive
@@ -102,7 +108,7 @@ type
     doStopCompile*: proc(): bool {.closure.}
     usageSym*: PSym # for nimsuggest
     owners*: seq[PSym]
-    suggestSymbols*: SuggestSymbolDatabase
+    suggestSymbols*: Table[FileIndex, seq[SymInfoPair]]
     suggestErrors*: Table[FileIndex, seq[Suggest]]
     methods*: seq[tuple[methods: seq[PSym], dispatcher: PSym]] # needs serialization!
     bucketTable*: CountTable[ItemId]
@@ -134,8 +140,6 @@ type
     idgen*: IdGenerator
     operators*: Operators
 
-    cachedFiles*: StringTableRef
-
   TPassContext* = object of RootObj # the pass's context
     idgen*: IdGenerator
   PPassContext* = ref TPassContext
@@ -258,7 +262,7 @@ proc nextModuleIter*(mi: var ModuleIter; g: ModuleGraph): PSym =
 iterator allSyms*(g: ModuleGraph; m: PSym): PSym =
   let importHidden = optImportHidden in m.options
   if isCachedModule(g, m):
-    var rodIt: RodIter = default(RodIter)
+    var rodIt: RodIter
     var r = initRodIterAllSyms(rodIt, g.config, g.cache, g.packed, FileIndex m.position, importHidden)
     while r != nil:
       yield r
@@ -275,30 +279,11 @@ proc someSym*(g: ModuleGraph; m: PSym; name: PIdent): PSym =
   else:
     result = strTableGet(g.ifaces[m.position].interfSelect(importHidden), name)
 
-proc someSymAmb*(g: ModuleGraph; m: PSym; name: PIdent; amb: var bool): PSym =
-  let importHidden = optImportHidden in m.options
-  if isCachedModule(g, m):
-    result = nil
-    for s in interfaceSymbols(g.config, g.cache, g.packed, FileIndex(m.position), name, importHidden):
-      if result == nil:
-        # set result to the first symbol
-        result = s
-      else:
-        # another symbol found
-        amb = true
-        break
-  else:
-    var ti: TIdentIter = default(TIdentIter)
-    result = initIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden), name)
-    if result != nil and nextIdentIter(ti, g.ifaces[m.position].interfSelect(importHidden)) != nil:
-      # another symbol exists with same name
-      amb = true
-
 proc systemModuleSym*(g: ModuleGraph; name: PIdent): PSym =
   result = someSym(g, g.systemModule, name)
 
 iterator systemModuleSyms*(g: ModuleGraph; name: PIdent): PSym =
-  var mi: ModuleIter = default(ModuleIter)
+  var mi: ModuleIter
   var r = initModuleIter(mi, g, g.systemModule, name)
   while r != nil:
     yield r
@@ -329,7 +314,7 @@ proc resolveInst(g: ModuleGraph; t: var LazyInstantiation): PInstantiation =
     t.inst = result
   assert result != nil
 
-proc resolveAttachedOp*(g: ModuleGraph; t: var LazySym): PSym =
+proc resolveAttachedOp(g: ModuleGraph; t: var LazySym): PSym =
   result = t.sym
   if result == nil:
     result = loadSymFromId(g.config, g.cache, g.packed, t.id.module, t.id.packed)
@@ -472,49 +457,6 @@ proc createMagic*(g: ModuleGraph; idgen: IdGenerator; name: string, m: TMagic):
 proc createMagic(g: ModuleGraph; name: string, m: TMagic): PSym =
   result = createMagic(g, g.idgen, name, m)
 
-proc uniqueModuleName*(conf: ConfigRef; m: PSym): string =
-  ## The unique module name is guaranteed to only contain {'A'..'Z', 'a'..'z', '0'..'9', '_'}
-  ## so that it is useful as a C identifier snippet.
-  let fid = FileIndex(m.position)
-  let path = AbsoluteFile toFullPath(conf, fid)
-  var isLib = false
-  var rel = ""
-  if path.string.startsWith(conf.libpath.string):
-    isLib = true
-    rel = relativeTo(path, conf.libpath).string
-  else:
-    rel = relativeTo(path, conf.projectPath).string
-
-  if not isLib and not belongsToProjectPackage(conf, m):
-    # special handlings for nimble packages
-    when DirSep == '\\':
-      let rel2 = replace(rel, '\\', '/')
-    else:
-      let rel2 = rel
-    const pkgs2 = "pkgs2/"
-    var start = rel2.find(pkgs2)
-    if start >= 0:
-      start += pkgs2.len
-      start += skipUntil(rel2, {'/'}, start)
-      if start+1 < rel2.len:
-        rel = "pkg/" & rel2[start+1..<rel.len] # strips paths
-
-  let trunc = if rel.endsWith(".nim"): rel.len - len(".nim") else: rel.len
-  result = newStringOfCap(trunc)
-  for i in 0..<trunc:
-    let c = rel[i]
-    case c
-    of 'a'..'z', '0'..'9':
-      result.add c
-    of {os.DirSep, os.AltSep}:
-      result.add 'Z' # because it looks a bit like '/'
-    of '.':
-      result.add 'O' # a circle
-    else:
-      # We mangle upper letters too so that there cannot
-      # be clashes with our special meanings of 'Z' and 'O'
-      result.addInt ord(c)
-
 proc registerModule*(g: ModuleGraph; m: PSym) =
   assert m != nil
   assert m.kind == skModule
@@ -526,7 +468,7 @@ proc registerModule*(g: ModuleGraph; m: PSym) =
     setLen(g.packed.pm, m.position + 1)
 
   g.ifaces[m.position] = Iface(module: m, converters: @[], patterns: @[],
-                               uniqueName: rope(uniqueModuleName(g.config, m)))
+                               uniqueName: rope(uniqueModuleName(g.config, FileIndex(m.position))))
   initStrTables(g, m)
 
 proc registerModuleById*(g: ModuleGraph; m: FileIndex) =
@@ -535,21 +477,19 @@ proc registerModuleById*(g: ModuleGraph; m: FileIndex) =
 proc initOperators*(g: ModuleGraph): Operators =
   # These are safe for IC.
   # Public because it's used by DrNim.
-  result = Operators(
-    opLe: createMagic(g, "<=", mLeI),
-    opLt: createMagic(g, "<", mLtI),
-    opAnd: createMagic(g, "and", mAnd),
-    opOr: createMagic(g, "or", mOr),
-    opIsNil: createMagic(g, "isnil", mIsNil),
-    opEq: createMagic(g, "==", mEqI),
-    opAdd: createMagic(g, "+", mAddI),
-    opSub: createMagic(g, "-", mSubI),
-    opMul: createMagic(g, "*", mMulI),
-    opDiv: createMagic(g, "div", mDivI),
-    opLen: createMagic(g, "len", mLengthSeq),
-    opNot: createMagic(g, "not", mNot),
-    opContains: createMagic(g, "contains", mInSet)
-  )
+  result.opLe = createMagic(g, "<=", mLeI)
+  result.opLt = createMagic(g, "<", mLtI)
+  result.opAnd = createMagic(g, "and", mAnd)
+  result.opOr = createMagic(g, "or", mOr)
+  result.opIsNil = createMagic(g, "isnil", mIsNil)
+  result.opEq = createMagic(g, "==", mEqI)
+  result.opAdd = createMagic(g, "+", mAddI)
+  result.opSub = createMagic(g, "-", mSubI)
+  result.opMul = createMagic(g, "*", mMulI)
+  result.opDiv = createMagic(g, "div", mDivI)
+  result.opLen = createMagic(g, "len", mLengthSeq)
+  result.opNot = createMagic(g, "not", mNot)
+  result.opContains = createMagic(g, "contains", mInSet)
 
 proc initModuleGraphFields(result: ModuleGraph) =
   # A module ID of -1 means that the symbol is not attached to a module at all,
@@ -562,7 +502,7 @@ proc initModuleGraphFields(result: ModuleGraph) =
   result.importStack = @[]
   result.inclToMod = initTable[FileIndex, FileIndex]()
   result.owners = @[]
-  result.suggestSymbols = initTable[FileIndex, SuggestFileSymbolDatabase]()
+  result.suggestSymbols = initTable[FileIndex, seq[SymInfoPair]]()
   result.suggestErrors = initTable[FileIndex, seq[Suggest]]()
   result.methods = @[]
   result.compilerprocs = initStrTable()
@@ -576,7 +516,6 @@ proc initModuleGraphFields(result: ModuleGraph) =
   result.symBodyHashes = initTable[int, SigHash]()
   result.operators = initOperators(result)
   result.emittedTypeInfo = initTable[string, FileIndex]()
-  result.cachedFiles = newStringTable()
 
 proc newModuleGraph*(cache: IdentCache; config: ConfigRef): ModuleGraph =
   result = ModuleGraph()
@@ -678,6 +617,7 @@ proc markDirty*(g: ModuleGraph; fileIdx: FileIndex) =
   if m != nil:
     g.suggestSymbols.del(fileIdx)
     g.suggestErrors.del(fileIdx)
+    g.resetForBackend
     incl m.flags, sfDirty
 
 proc unmarkAllDirty*(g: ModuleGraph) =
@@ -740,6 +680,8 @@ proc moduleFromRodFile*(g: ModuleGraph; fileIdx: FileIndex;
 proc configComplete*(g: ModuleGraph) =
   rememberStartupConfig(g.startupPackedConfig, g.config)
 
+from std/strutils import repeat, `%`
+
 proc onProcessing*(graph: ModuleGraph, fileIdx: FileIndex, moduleStatus: string, fromModule: PSym, ) =
   let conf = graph.config
   let isNimscript = conf.isDefined("nimscript")
@@ -765,14 +707,16 @@ func belongsToStdlib*(graph: ModuleGraph, sym: PSym): bool =
   ## Check if symbol belongs to the 'stdlib' package.
   sym.getPackageSymbol.getPackageId == graph.systemModule.getPackageId
 
-proc fileSymbols*(graph: ModuleGraph, fileIdx: FileIndex): SuggestFileSymbolDatabase =
-  result = graph.suggestSymbols.getOrDefault(fileIdx, newSuggestFileSymbolDatabase(fileIdx, optIdeExceptionInlayHints in graph.config.globalOptions))
-  doAssert(result.fileIndex == fileIdx)
+proc `==`*(a, b: SymInfoPair): bool =
+  result = a.sym == b.sym and a.info.exactEquals(b.info)
+
+proc fileSymbols*(graph: ModuleGraph, fileIdx: FileIndex): seq[SymInfoPair] =
+  result = graph.suggestSymbols.getOrDefault(fileIdx, @[])
 
 iterator suggestSymbolsIter*(g: ModuleGraph): SymInfoPair =
   for xs in g.suggestSymbols.values:
-    for i in xs.lineInfo.low..xs.lineInfo.high:
-      yield xs.getSymInfoPair(i)
+    for x in xs:
+      yield x
 
 iterator suggestErrorsIter*(g: ModuleGraph): Suggest =
   for xs in g.suggestErrors.values:

compiler/modulepaths.nim

@@ -38,18 +38,11 @@ proc getModuleName*(conf: ConfigRef; n: PNode): string =
           localError(n.info, "only '/' supported with $package notation")
           result = ""
     else:
-      if n0.kind in nkIdentKinds:
-        let ident = n0.getPIdent
-        if ident != nil and ident.s[0] == '/':
-          let modname = getModuleName(conf, n[2])
-          # hacky way to implement 'x / y /../ z':
-          result = getModuleName(conf, n1)
-          result.add renderTree(n0, {renderNoComments}).replace(" ")
-          result.add modname
-        else:
-          result = ""
-      else:
-        result = ""
+      let modname = getModuleName(conf, n[2])
+      # hacky way to implement 'x / y /../ z':
+      result = getModuleName(conf, n1)
+      result.add renderTree(n0, {renderNoComments}).replace(" ")
+      result.add modname
   of nkPrefix:
     when false:
       if n[0].kind == nkIdent and n[0].ident.s == "$":

compiler/modules.nim

@@ -14,9 +14,6 @@ import
   idents, lexer, syntaxes, modulegraphs,
   lineinfos, pathutils
 
-import ../dist/checksums/src/checksums/sha1
-import std/strtabs
-
 proc resetSystemArtifacts*(g: ModuleGraph) =
   magicsys.resetSysTypes(g)
 
@@ -25,7 +22,7 @@ template getModuleIdent(graph: ModuleGraph, filename: AbsoluteFile): PIdent =
 
 proc partialInitModule*(result: PSym; graph: ModuleGraph; fileIdx: FileIndex; filename: AbsoluteFile) =
   let packSym = getPackage(graph, fileIdx)
-  setOwner(result, packSym)
+  result.owner = packSym
   result.position = int fileIdx
 
 proc newModule*(graph: ModuleGraph; fileIdx: FileIndex): PSym =
@@ -45,8 +42,6 @@ proc includeModule*(graph: ModuleGraph; s: PSym, fileIdx: FileIndex): PNode =
   result = syntaxes.parseFile(fileIdx, graph.cache, graph.config)
   graph.addDep(s, fileIdx)
   graph.addIncludeDep(s.position.FileIndex, fileIdx)
-  let path = toFullPath(graph.config, fileIdx)
-  graph.cachedFiles[path] = $secureHashFile(path)
 
 proc wantMainModule*(conf: ConfigRef) =
   if conf.projectFull.isEmpty:

compiler/msgs.nim

@@ -60,13 +60,31 @@ proc makeCString*(s: string): Rope =
     toCChar(s[i], result)
   result.add('\"')
 
+proc makeCCharArray*(s: string): Rope =
+  result = newStringOfCap(int(s.len.toFloat * 1.1) + 1)
+  result.add("{")
+  for i in 0..<s.len:
+    # line wrapping of string litterals in cgen'd code was a bad idea, e.g. causes: bug #16265
+    # It also makes reading c sources or grepping harder, for zero benefit.
+    # const MaxLineLength = 64
+    # if (i + 1) mod MaxLineLength == 0:
+    #   res.add("\"\L\"")
+    if i != 0:
+      result.add ", "
+    result.add '\''
+    toCChar(s[i], result)
+    result.add '\''
+  result.add('}')
+
 proc newFileInfo(fullPath: AbsoluteFile, projPath: RelativeFile): TFileInfo =
-  result = TFileInfo(fullPath: fullPath, projPath: projPath,
-                    shortName: fullPath.extractFilename,
-                    quotedFullName: fullPath.string.makeCString,
-                    lines: @[]
-  )
+  result.fullPath = fullPath
+  #shallow(result.fullPath)
+  result.projPath = projPath
+  #shallow(result.projPath)
+  result.shortName = fullPath.extractFilename
   result.quotedName = result.shortName.makeCString
+  result.quotedFullName = fullPath.string.makeCString
+  result.lines = @[]
   when defined(nimpretty):
     if not result.fullPath.isEmpty:
       try:
@@ -123,18 +141,18 @@ proc fileInfoIdx*(conf: ConfigRef; filename: AbsoluteFile; isKnownFile: var bool
     conf.m.filenameToIndexTbl[canon2] = result
 
 proc fileInfoIdx*(conf: ConfigRef; filename: AbsoluteFile): FileIndex =
-  var dummy: bool = false
+  var dummy: bool
   result = fileInfoIdx(conf, filename, dummy)
 
 proc fileInfoIdx*(conf: ConfigRef; filename: RelativeFile; isKnownFile: var bool): FileIndex =
   fileInfoIdx(conf, AbsoluteFile expandFilename(filename.string), isKnownFile)
 
 proc fileInfoIdx*(conf: ConfigRef; filename: RelativeFile): FileIndex =
-  var dummy: bool = false
+  var dummy: bool
   fileInfoIdx(conf, AbsoluteFile expandFilename(filename.string), dummy)
 
 proc newLineInfo*(fileInfoIdx: FileIndex, line, col: int): TLineInfo =
-  result = TLineInfo(fileIndex: fileInfoIdx)
+  result.fileIndex = fileInfoIdx
   if line < int high(uint16):
     result.line = uint16(line)
   else:
@@ -429,8 +447,7 @@ To create a stacktrace, rerun compilation with './koch temp $1 <file>', see $2 f
 proc handleError(conf: ConfigRef; msg: TMsgKind, eh: TErrorHandling, s: string, ignoreMsg: bool) =
   if msg in fatalMsgs:
     if conf.cmd == cmdIdeTools: log(s)
-    if conf.cmd != cmdIdeTools or msg != errFatal:
-      quit(conf, msg)
+    quit(conf, msg)
   if msg >= errMin and msg <= errMax or
       (msg in warnMin..hintMax and msg in conf.warningAsErrors and not ignoreMsg):
     inc(conf.errorCounter)
@@ -438,11 +455,7 @@ proc handleError(conf: ConfigRef; msg: TMsgKind, eh: TErrorHandling, s: string,
     if conf.errorCounter >= conf.errorMax:
       # only really quit when we're not in the new 'nim check --def' mode:
       if conf.ideCmd == ideNone:
-        when defined(nimsuggest):
-          #we need to inform the user that something went wrong when initializing NimSuggest
-          raiseRecoverableError(s)
-        else:
-          quit(conf, msg)
+        quit(conf, msg)
     elif eh == doAbort and conf.cmd != cmdIdeTools:
       quit(conf, msg)
     elif eh == doRaise:
@@ -560,10 +573,9 @@ proc liMessage*(conf: ConfigRef; info: TLineInfo, msg: TMsgKind, arg: string,
     ignoreMsg = not conf.hasHint(msg)
     if not ignoreMsg and msg in conf.warningAsErrors:
       title = ErrorTitle
-      color = ErrorColor
     else:
       title = HintTitle
-      color = HintColor
+    color = HintColor
     inc(conf.hintCounter)
 
   let s = if isRaw: arg else: getMessageStr(msg, arg)
@@ -629,7 +641,7 @@ proc warningDeprecated*(conf: ConfigRef, info: TLineInfo = gCmdLineInfo, msg = "
   message(conf, info, warnDeprecated, msg)
 
 proc internalErrorImpl(conf: ConfigRef; info: TLineInfo, errMsg: string, info2: InstantiationInfo) =
-  if conf.cmd in {cmdIdeTools, cmdCheck} and conf.structuredErrorHook.isNil: return
+  if conf.cmd == cmdIdeTools and conf.structuredErrorHook.isNil: return
   writeContext(conf, info)
   liMessage(conf, info, errInternal, errMsg, doAbort, info2)
 
@@ -651,16 +663,13 @@ template lintReport*(conf: ConfigRef; info: TLineInfo, beau, got: string, extraM
   let msg = if optStyleError in conf.globalOptions: errGenerated else: hintName
   liMessage(conf, info, msg, m, doNothing, instLoc())
 
-proc quotedFilename*(conf: ConfigRef; fi: FileIndex): Rope =
-  if fi.int32 < 0:
+proc quotedFilename*(conf: ConfigRef; i: TLineInfo): Rope =
+  if i.fileIndex.int32 < 0:
     result = makeCString "???"
   elif optExcessiveStackTrace in conf.globalOptions:
-    result = conf.m.fileInfos[fi.int32].quotedFullName
+    result = conf.m.fileInfos[i.fileIndex.int32].quotedFullName
   else:
-    result = conf.m.fileInfos[fi.int32].quotedName
-
-proc quotedFilename*(conf: ConfigRef; i: TLineInfo): Rope =
-  quotedFilename(conf, i.fileIndex)
+    result = conf.m.fileInfos[i.fileIndex.int32].quotedName
 
 template listMsg(title, r) =
   msgWriteln(conf, title, {msgNoUnitSep})
@@ -669,6 +678,31 @@ template listMsg(title, r) =
 proc listWarnings*(conf: ConfigRef) = listMsg("Warnings:", warnMin..warnMax)
 proc listHints*(conf: ConfigRef) = listMsg("Hints:", hintMin..hintMax)
 
+proc uniqueModuleName*(conf: ConfigRef; fid: FileIndex): string =
+  ## The unique module name is guaranteed to only contain {'A'..'Z', 'a'..'z', '0'..'9', '_'}
+  ## so that it is useful as a C identifier snippet.
+  let path = AbsoluteFile toFullPath(conf, fid)
+  let rel =
+    if path.string.startsWith(conf.libpath.string):
+      relativeTo(path, conf.libpath).string
+    else:
+      relativeTo(path, conf.projectPath).string
+  let trunc = if rel.endsWith(".nim"): rel.len - len(".nim") else: rel.len
+  result = newStringOfCap(trunc)
+  for i in 0..<trunc:
+    let c = rel[i]
+    case c
+    of 'a'..'z':
+      result.add c
+    of {os.DirSep, os.AltSep}:
+      result.add 'Z' # because it looks a bit like '/'
+    of '.':
+      result.add 'O' # a circle
+    else:
+      # We mangle upper letters and digits too so that there cannot
+      # be clashes with our special meanings of 'Z' and 'O'
+      result.addInt ord(c)
+
 proc genSuccessX*(conf: ConfigRef) =
   let mem =
     when declared(system.getMaxMem): formatSize(getMaxMem()) & " peakmem"

compiler/ndi.nim

@@ -0,0 +1,52 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2017 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module implements the generation of ``.ndi`` files for better debugging
+## support of Nim code. "ndi" stands for "Nim debug info".
+
+import ast, msgs, ropes, options, pathutils
+
+when defined(nimPreviewSlimSystem):
+  import std/[syncio, assertions]
+
+type
+  NdiFile* = object
+    enabled: bool
+    f: File
+    buf: string
+    filename: AbsoluteFile
+    syms: seq[PSym]
+
+proc doWrite(f: var NdiFile; s: PSym; conf: ConfigRef) =
+  f.buf.setLen 0
+  f.buf.addInt s.info.line.int
+  f.buf.add "\t"
+  f.buf.addInt s.info.col.int
+  f.f.write(s.name.s, "\t")
+  f.f.writeRope(s.loc.r)
+  f.f.writeLine("\t", toFullPath(conf, s.info), "\t", f.buf)
+
+template writeMangledName*(f: NdiFile; s: PSym; conf: ConfigRef) =
+  if f.enabled: f.syms.add s
+
+proc open*(f: var NdiFile; filename: AbsoluteFile; conf: ConfigRef) =
+  f.enabled = not filename.isEmpty
+  if f.enabled:
+    f.filename = filename
+    f.buf = newStringOfCap(20)
+
+proc close*(f: var NdiFile, conf: ConfigRef) =
+  if f.enabled:
+    f.f = open(f.filename.string, fmWrite, 8000)
+    doAssert f.f != nil, f.filename.string
+    for s in f.syms:
+      doWrite(f, s, conf)
+    close(f.f)
+    f.syms.reset
+    f.filename.reset

compiler/nilcheck.nim

@@ -498,7 +498,7 @@ proc checkCall(n, ctx, map): Check =
   # check args and handle possible mutations
 
   var isNew = false
-  result = Check(map: map)
+  result.map = map
   for i, child in n:
     discard check(child, ctx, map)
 
@@ -507,7 +507,7 @@ proc checkCall(n, ctx, map): Check =
       # as it might have been mutated
       # TODO similar for normal refs and fields: find dependent exprs: brackets
 
-      if child.kind == nkHiddenAddr and not child.typ.isNil and child.typ.kind == tyVar and child.typ.elementType.kind == tyRef:
+      if child.kind == nkHiddenAddr and not child.typ.isNil and child.typ.kind == tyVar and child.typ[0].kind == tyRef:
         if not isNew:
           result.map = newNilMap(map)
           isNew = true
@@ -753,7 +753,6 @@ proc checkReturn(n, ctx, map): Check =
 
 proc checkIf(n, ctx, map): Check =
   ## check branches based on condition
-  result = default(Check)
   var mapIf: NilMap = map
 
   # first visit the condition
@@ -826,7 +825,7 @@ proc checkFor(n, ctx, map): Check =
   var check2 = check(n.sons[2], ctx, m)
   var map2 = check2.map
 
-  result = Check(map: ctx.union(map0, m))
+  result.map = ctx.union(map0, m)
   result.map = ctx.union(result.map, map2)
   result.nilability = Safe
 
@@ -854,7 +853,7 @@ proc checkWhile(n, ctx, map): Check =
   var check2 = check(n.sons[1], ctx, m)
   var map2 = check2.map
 
-  result = Check(map: ctx.union(map0, map1))
+  result.map = ctx.union(map0, map1)
   result.map = ctx.union(result.map, map2)
   result.nilability = Safe
 
@@ -900,7 +899,7 @@ proc checkInfix(n, ctx, map): Check =
 proc checkIsNil(n, ctx, map; isElse: bool = false): Check =
   ## check isNil calls
   ## update the map depending on if it is not isNil or isNil
-  result = Check(map: newNilMap(map))
+  result.map = newNilMap(map)
   let value = n[1]
   result.map.store(ctx, ctx.index(n[1]), if not isElse: Nil else: Safe, TArg, n.info, n)
 
@@ -919,7 +918,7 @@ proc infix(ctx: NilCheckerContext, l: PNode, r: PNode, magic: TMagic): PNode =
     newSymNode(op, r.info),
     l,
     r)
-  result.typ() = newType(tyBool, ctx.idgen, nil)
+  result.typ = newType(tyBool, ctx.idgen, nil)
 
 proc prefixNot(ctx: NilCheckerContext, node: PNode): PNode =
   var cache = newIdentCache()
@@ -929,7 +928,7 @@ proc prefixNot(ctx: NilCheckerContext, node: PNode): PNode =
   result = nkPrefix.newTree(
     newSymNode(op, node.info),
     node)
-  result.typ() = newType(tyBool, ctx.idgen, nil)
+  result.typ = newType(tyBool, ctx.idgen, nil)
 
 proc infixEq(ctx: NilCheckerContext, l: PNode, r: PNode): PNode =
   infix(ctx, l, r, mEqRef)
@@ -948,7 +947,7 @@ proc checkCase(n, ctx, map): Check =
   #   c2
   # also a == true is a , a == false is not a
   let base = n[0]
-  result = Check(map: map.copyMap())
+  result.map = map.copyMap()
   result.nilability = Safe
   var a: PNode = nil
   for child in n:
@@ -1220,7 +1219,7 @@ proc check(n: PNode, ctx: NilCheckerContext, map: NilMap): Check =
     result = check(n.sons[1], ctx, map)
   of nkStmtList, nkStmtListExpr, nkChckRangeF, nkChckRange64, nkChckRange,
      nkBracket, nkCurly, nkPar, nkTupleConstr, nkClosure, nkObjConstr, nkElse:
-    result = Check(map: map)
+    result.map = map
     if n.kind in {nkObjConstr, nkTupleConstr}:
       # TODO deeper nested elements?
       # A(field: B()) #
@@ -1247,10 +1246,10 @@ proc check(n: PNode, ctx: NilCheckerContext, map: NilMap): Check =
     result = checkIf(n, ctx, map)
   of nkAsgn, nkFastAsgn, nkSinkAsgn:
     result = checkAsgn(n[0], n[1], ctx, map)
-  of nkVarSection, nkLetSection:
-    result = Check(map: map)
+  of nkVarSection:
+    result.map = map
     for child in n:
-      result = checkAsgn(child[0].skipPragmaExpr, child[2], ctx, result.map)
+      result = checkAsgn(child[0], child[2], ctx, result.map)
   of nkForStmt:
     result = checkFor(n, ctx, map)
   of nkCaseStmt:
@@ -1274,7 +1273,8 @@ proc check(n: PNode, ctx: NilCheckerContext, map: NilMap): Check =
   else:
 
     var elementMap = map.copyMap()
-    var elementCheck = Check(map: elementMap)
+    var elementCheck: Check
+    elementCheck.map = elementMap
     for element in n:
       elementCheck = check(element, ctx, elementCheck.map)
 
@@ -1367,7 +1367,7 @@ proc checkNil*(s: PSym; body: PNode; conf: ConfigRef, idgen: IdGenerator) =
         continue
       map.store(context, context.index(child), typeNilability(child.typ), TArg, child.info, child)
 
-  map.store(context, resultExprIndex, if not s.typ.returnType.isNil and s.typ.returnType.kind == tyRef: Nil else: Safe, TResult, s.ast.info)
+  map.store(context, resultExprIndex, if not s.typ[0].isNil and s.typ[0].kind == tyRef: Nil else: Safe, TResult, s.ast.info)
 
   # echo "checking ", s.name.s, " ", filename
 
@@ -1383,5 +1383,5 @@ proc checkNil*(s: PSym; body: PNode; conf: ConfigRef, idgen: IdGenerator) =
   # (ANotNil, BNotNil) :
   # do we check on asgn nilability at all?
 
-  if not s.typ.returnType.isNil and s.typ.returnType.kind == tyRef and tfNotNil in s.typ.returnType.flags:
+  if not s.typ[0].isNil and s.typ[0].kind == tyRef and tfNotNil in s.typ[0].flags:
     checkResult(s.ast, context, res.map)

compiler/nim.cfg

@@ -4,6 +4,7 @@ hint[XDeclaredButNotUsed]:off
 
 define:booting
 define:nimcore
+define:nimPreviewFloatRoundtrip
 define:nimPreviewSlimSystem
 define:nimPreviewCstringConversion
 define:nimPreviewProcConversion

compiler/nim.nim

@@ -116,9 +116,8 @@ proc handleCmdLine(cache: IdentCache; conf: ConfigRef) =
     conf.backend = backendC
 
   if conf.selectedGC == gcUnselected:
-    if conf.backend in {backendC, backendCpp, backendObjc} or
-        (conf.cmd in cmdDocLike and conf.backend != backendJs) or
-        conf.cmd == cmdGendepend:
+    if conf.backend in {backendC, backendCpp, backendObjc, backendNir} or
+        (conf.cmd == cmdInteractive and isDefined(conf, "nir")):
       initOrcDefines(conf)
 
   mainCommand(graph)

compiler/nimblecmd.nim

@@ -79,8 +79,6 @@ proc getPathVersionChecksum*(p: string): tuple[name, version, checksum: string]
   ## ``/home/user/.nimble/pkgs/package-0.1-febadeaea2345e777f0f6f8433f7f0a52edd5d1b`` into
   ## ``("/home/user/.nimble/pkgs/package", "0.1", "febadeaea2345e777f0f6f8433f7f0a52edd5d1b")``
 
-  result = ("", "", "")
-
   const checksumSeparator = '-'
   const versionSeparator = '-'
   const specialVersionSepartator = "-#"

compiler/nimconf.nim

@@ -223,7 +223,7 @@ proc readConfigFile*(filename: AbsoluteFile; cache: IdentCache;
   stream = llStreamOpen(filename, fmRead)
   if stream != nil:
     openLexer(L, filename, stream, cache, config)
-    tok = Token(tokType: tkEof)       # to avoid a pointless warning
+    tok.tokType = tkEof       # to avoid a pointless warning
     var condStack: seq[bool] = @[]
     confTok(L, tok, config, condStack)           # read in the first token
     while tok.tokType != tkEof: parseAssignment(L, tok, config, filename, condStack)

compiler/nimeval.nim

@@ -11,8 +11,8 @@
 import
   ast, modules, condsyms,
   options, llstream, lineinfos, vm,
-  vmdef, modulegraphs, idents, pathutils,
-  scriptconfig, std/[compilesettings, tables, os]
+  vmdef, modulegraphs, idents, os, pathutils,
+  scriptconfig, std/[compilesettings, tables]
 
 import pipelines
 
@@ -40,7 +40,7 @@ proc selectUniqueSymbol*(i: Interpreter; name: string;
   assert i != nil
   assert i.mainModule != nil, "no main module selected"
   let n = getIdent(i.graph.cache, name)
-  var it: ModuleIter = default(ModuleIter)
+  var it: ModuleIter
   var s = initModuleIter(it, i.graph, i.mainModule, n)
   result = nil
   while s != nil:

compiler/nimsets.nim

@@ -65,7 +65,7 @@ proc toBitSet*(conf: ConfigRef; s: PNode): TBitSet =
   result = @[]
   var first: Int128 = Zero
   var j: Int128 = Zero
-  first = firstOrd(conf, s.typ.elementType)
+  first = firstOrd(conf, s.typ[0])
   bitSetInit(result, int(getSize(conf, s.typ)))
   for i in 0..<s.len:
     if s[i].kind == nkRange:
@@ -84,7 +84,7 @@ proc toTreeSet*(conf: ConfigRef; s: TBitSet, settype: PType, info: TLineInfo): P
   elemType = settype[0]
   first = firstOrd(conf, elemType).toInt64
   result = newNodeI(nkCurly, info)
-  result.typ() = settype
+  result.typ = settype
   result.info = info
   e = 0
   while e < s.len * ElemSize:
@@ -101,7 +101,7 @@ proc toTreeSet*(conf: ConfigRef; s: TBitSet, settype: PType, info: TLineInfo): P
         result.add aa
       else:
         n = newNodeI(nkRange, info)
-        n.typ() = elemType
+        n.typ = elemType
         n.add aa
         let bb = newIntTypeNode(b + first, elemType)
         bb.info = info

compiler/nir/cir.nim

@@ -0,0 +1,983 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# We produce C code as a list of tokens.
+
+import std / [assertions, syncio, tables, intsets, formatfloat]
+from std / strutils import toOctal
+import .. / ic / [bitabs, rodfiles]
+import nirtypes, nirinsts, nirfiles
+import ../../dist/checksums/src/checksums/md5
+
+type
+  Token = LitId # indexing into the tokens BiTable[string]
+
+  PredefinedToken = enum
+    IgnoreMe = "<unused>"
+    EmptyToken = ""
+    CurlyLe = "{"
+    CurlyRi = "}"
+    ParLe = "("
+    ParRi = ")"
+    BracketLe = "["
+    BracketRi = "]"
+    NewLine = "\n"
+    Semicolon = ";"
+    Comma = ", "
+    Space = " "
+    Colon = ": "
+    Dot = "."
+    Arrow = "->"
+    Star = "*"
+    Amp = "&"
+    AsgnOpr = " = "
+    ScopeOpr = "::"
+    ConstKeyword = "const "
+    StaticKeyword = "static "
+    ExternKeyword = "extern "
+    WhileKeyword = "while "
+    IfKeyword = "if ("
+    ElseKeyword = "else "
+    SwitchKeyword = "switch "
+    CaseKeyword = "case "
+    DefaultKeyword = "default:"
+    BreakKeyword = "break"
+    NullPtr = "nullptr"
+    IfNot = "if (!("
+    ReturnKeyword = "return "
+    TypedefStruct = "typedef struct "
+    TypedefUnion = "typedef union "
+    IncludeKeyword = "#include "
+
+proc fillTokenTable(tab: var BiTable[string]) =
+  for e in EmptyToken..high(PredefinedToken):
+    let id = tab.getOrIncl $e
+    assert id == LitId(e), $(id, " ", ord(e))
+
+type
+  GeneratedCode* = object
+    m: NirModule
+    includes: seq[LitId]
+    includedHeaders: IntSet
+    data: seq[LitId]
+    protos: seq[LitId]
+    code: seq[LitId]
+    init: seq[LitId]
+    tokens: BiTable[string]
+    emittedStrings: IntSet
+    needsPrefix: IntSet
+    generatedTypes: IntSet
+    mangledModules: Table[LitId, LitId]
+
+proc initGeneratedCode*(m: sink NirModule): GeneratedCode =
+  result = GeneratedCode(m: m, code: @[], tokens: initBiTable[string]())
+  fillTokenTable(result.tokens)
+
+proc add*(g: var GeneratedCode; t: PredefinedToken) {.inline.} =
+  g.code.add Token(t)
+
+proc add*(g: var GeneratedCode; s: string) {.inline.} =
+  g.code.add g.tokens.getOrIncl(s)
+
+proc mangleModuleName(c: var GeneratedCode; key: LitId): LitId =
+  result = c.mangledModules.getOrDefault(key, LitId(0))
+  if result == LitId(0):
+    let u {.cursor.} = c.m.lit.strings[key]
+    var last = u.len - len(".nim") - 1
+    var start = last
+    while start >= 0 and u[start] != '/': dec start
+    var sum = getMD5(u)
+    sum.setLen(8)
+    let dest = u.substr(start+1, last) & sum
+    result = c.tokens.getOrIncl(dest)
+    c.mangledModules[key] = result
+
+type
+  CppFile = object
+    f: File
+
+proc write(f: var CppFile; s: string) = write(f.f, s)
+proc write(f: var CppFile; c: char) = write(f.f, c)
+
+proc writeTokenSeq(f: var CppFile; s: seq[Token]; c: GeneratedCode) =
+  var indent = 0
+  for i in 0..<s.len:
+    let x = s[i]
+    case x
+    of Token(CurlyLe):
+      inc indent
+      write f, c.tokens[x]
+      write f, "\n"
+      for i in 1..indent*2: write f, ' '
+    of Token(CurlyRi):
+      dec indent
+      write f, c.tokens[x]
+      if i+1 < s.len and s[i+1] == Token(CurlyRi):
+        discard
+      else:
+        write f, "\n"
+        for i in 1..indent*2: write f, ' '
+    of Token(Semicolon):
+      write f, c.tokens[x]
+      if i+1 < s.len and s[i+1] == Token(CurlyRi):
+        discard "no newline before }"
+      else:
+        write f, "\n"
+        for i in 1..indent*2: write f, ' '
+    of Token(NewLine):
+      write f, c.tokens[x]
+      for i in 1..indent*2: write f, ' '
+    else:
+      write f, c.tokens[x]
+
+
+# Type graph
+
+type
+  TypeList = object
+    processed: IntSet
+    s: seq[(TypeId, PredefinedToken)]
+
+proc add(dest: var TypeList; elem: TypeId; decl: PredefinedToken) =
+  if not containsOrIncl(dest.processed, int(elem)):
+    dest.s.add (elem, decl)
+
+type
+  TypeOrder = object
+    forwardedDecls, ordered: TypeList
+    typeImpls: Table[string, TypeId]
+    lookedAt: IntSet
+
+proc traverseObject(types: TypeGraph; lit: Literals; c: var TypeOrder; t: TypeId)
+
+proc recordDependency(types: TypeGraph; lit: Literals; c: var TypeOrder; parent, child: TypeId) =
+  var ch = child
+  var viaPointer = false
+  while true:
+    case types[ch].kind
+    of APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy:
+      viaPointer = true
+      ch = elementType(types, ch)
+    of LastArrayTy:
+      ch = elementType(types, ch)
+    else:
+      break
+
+  case types[ch].kind
+  of ObjectTy, UnionTy:
+    let decl = if types[ch].kind == ObjectTy: TypedefStruct else: TypedefUnion
+    let obj = c.typeImpls.getOrDefault(lit.strings[types[ch].litId])
+    if viaPointer:
+      c.forwardedDecls.add obj, decl
+    else:
+      if not containsOrIncl(c.lookedAt, obj.int):
+        traverseObject(types, lit, c, obj)
+      c.ordered.add obj, decl
+  of ArrayTy:
+    if viaPointer:
+      c.forwardedDecls.add ch, TypedefStruct
+    else:
+      if not containsOrIncl(c.lookedAt, ch.int):
+        traverseObject(types, lit, c, ch)
+      c.ordered.add ch, TypedefStruct
+  else:
+    discard "uninteresting type as we only focus on the required struct declarations"
+
+proc traverseObject(types: TypeGraph; lit: Literals; c: var TypeOrder; t: TypeId) =
+  for x in sons(types, t):
+    case types[x].kind
+    of FieldDecl:
+      recordDependency types, lit, c, t, x.firstSon
+    of ObjectTy:
+      # inheritance
+      recordDependency types, lit, c, t, x
+    else: discard
+
+proc traverseTypes(types: TypeGraph; lit: Literals; c: var TypeOrder) =
+  for t in allTypes(types):
+    if types[t].kind in {ObjectDecl, UnionDecl}:
+      assert types[t.firstSon].kind == NameVal
+      c.typeImpls[lit.strings[types[t.firstSon].litId]] = t
+
+  for t in allTypesIncludingInner(types):
+    case types[t].kind
+    of ObjectDecl, UnionDecl:
+      traverseObject types, lit, c, t
+      let decl = if types[t].kind == ObjectDecl: TypedefStruct else: TypedefUnion
+      c.ordered.add t, decl
+    of ArrayTy:
+      traverseObject types, lit, c, t
+      c.ordered.add t, TypedefStruct
+    else: discard
+
+when false:
+  template emitType(s: string) = c.types.add c.tokens.getOrIncl(s)
+  template emitType(t: Token) = c.types.add t
+  template emitType(t: PredefinedToken) = c.types.add Token(t)
+
+proc genType(g: var GeneratedCode; types: TypeGraph; lit: Literals; t: TypeId; name = "") =
+  template maybeAddName =
+    if name != "":
+      g.add Space
+      g.add name
+
+  template atom(s: string) =
+    g.add s
+    maybeAddName()
+  case types[t].kind
+  of VoidTy: atom "void"
+  of IntTy: atom "NI" & $types[t].integralBits
+  of UIntTy: atom "NU" & $types[t].integralBits
+  of FloatTy: atom "NF" & $types[t].integralBits
+  of BoolTy: atom "NB" & $types[t].integralBits
+  of CharTy: atom "NC" & $types[t].integralBits
+  of ObjectTy, UnionTy, NameVal, AnnotationVal:
+    atom lit.strings[types[t].litId]
+  of VarargsTy:
+    g.add "..."
+  of APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy:
+    genType g, types, lit, elementType(types, t)
+    g.add Star
+    maybeAddName()
+  of ArrayTy:
+    genType g, types, lit, arrayName(types, t)
+    maybeAddName()
+  of LastArrayTy:
+    genType g, types, lit, elementType(types, t)
+    maybeAddName()
+    g.add BracketLe
+    g.add BracketRi
+  of ProcTy:
+    let (retType, callConv) = returnType(types, t)
+    genType g, types, lit, retType
+    g.add Space
+    g.add ParLe
+    genType g, types, lit, callConv
+    g.add Star # "(*fn)"
+    maybeAddName()
+    g.add ParRi
+    g.add ParLe
+    var i = 0
+    for ch in params(types, t):
+      if i > 0: g.add Comma
+      genType g, types, lit, ch
+      inc i
+    g.add ParRi
+  of ObjectDecl, UnionDecl:
+    atom lit.strings[types[t.firstSon].litId]
+  of IntVal, SizeVal, AlignVal, OffsetVal, FieldDecl:
+    #raiseAssert "did not expect: " & $types[t].kind
+    g.add "BUG "
+    atom $types[t].kind
+
+proc generateTypes(g: var GeneratedCode; types: TypeGraph; lit: Literals; c: TypeOrder) =
+  for (t, declKeyword) in c.forwardedDecls.s:
+    let name = if types[t].kind == ArrayTy: arrayName(types, t) else: t.firstSon
+    let s {.cursor.} = lit.strings[types[name].litId]
+    g.add declKeyword
+    g.add s
+    g.add Space
+    g.add s
+    g.add Semicolon
+
+  for (t, declKeyword) in c.ordered.s:
+    let name = if types[t].kind == ArrayTy: arrayName(types, t) else: t.firstSon
+    let litId = types[name].litId
+    if not g.generatedTypes.containsOrIncl(litId.int):
+      let s {.cursor.} = lit.strings[litId]
+      g.add declKeyword
+      g.add CurlyLe
+      if types[t].kind == ArrayTy:
+        genType g, types, lit, elementType(types, t), "a"
+        g.add BracketLe
+        g.add $arrayLen(types, t)
+        g.add BracketRi
+        g.add Semicolon
+      else:
+        var i = 0
+        for x in sons(types, t):
+          case types[x].kind
+          of FieldDecl:
+            genType g, types, lit, x.firstSon, "F" & $i
+            g.add Semicolon
+            inc i
+          of ObjectTy:
+            genType g, types, lit, x, "P"
+            g.add Semicolon
+          else: discard
+      g.add CurlyRi
+      g.add s
+      g.add Semicolon
+
+# Procs
+
+proc toCChar*(c: char; result: var string) {.inline.} =
+  case c
+  of '\0'..'\x1F', '\x7F'..'\xFF':
+    result.add '\\'
+    result.add toOctal(c)
+  of '\'', '\"', '\\', '?':
+    result.add '\\'
+    result.add c
+  else:
+    result.add c
+
+proc makeCString(s: string): string =
+  result = newStringOfCap(s.len + 10)
+  result.add('"')
+  for c in s: toCChar(c, result)
+  result.add('"')
+
+template emitData(s: string) = c.data.add c.tokens.getOrIncl(s)
+template emitData(t: Token) = c.data.add t
+template emitData(t: PredefinedToken) = c.data.add Token(t)
+
+proc genStrLit(c: var GeneratedCode; lit: Literals; litId: LitId): Token =
+  result = Token(c.tokens.getOrIncl "QStr" & $litId)
+  if not containsOrIncl(c.emittedStrings, int(litId)):
+    let s {.cursor.} = lit.strings[litId]
+    emitData "static const struct "
+    emitData CurlyLe
+    emitData "NI cap"
+    emitData Semicolon
+    emitData "NC8 data"
+    emitData BracketLe
+    emitData $s.len
+    emitData "+1"
+    emitData BracketRi
+    emitData Semicolon
+    emitData CurlyRi
+    emitData result
+    emitData AsgnOpr
+    emitData CurlyLe
+    emitData $s.len
+    emitData " | NIM_STRLIT_FLAG"
+    emitData Comma
+    emitData makeCString(s)
+    emitData CurlyRi
+    emitData Semicolon
+
+proc genIntLit(c: var GeneratedCode; lit: Literals; litId: LitId) =
+  let i = lit.numbers[litId]
+  if i > low(int32) and i <= high(int32):
+    c.add $i
+  elif i == low(int32):
+    # Nim has the same bug for the same reasons :-)
+    c.add "(-2147483647 -1)"
+  elif i > low(int64):
+    c.add "IL64("
+    c.add $i
+    c.add ")"
+  else:
+    c.add "(IL64(-9223372036854775807) - IL64(1))"
+
+proc gen(c: var GeneratedCode; t: Tree; n: NodePos)
+
+proc genDisplayName(c: var GeneratedCode; symId: SymId) =
+  let displayName = c.m.symnames[symId]
+  if displayName != LitId(0):
+    c.add "/*"
+    c.add c.m.lit.strings[displayName]
+    c.add "*/"
+
+proc genSymDef(c: var GeneratedCode; t: Tree; n: NodePos) =
+  if t[n].kind == SymDef:
+    let symId = t[n].symId
+    c.needsPrefix.incl symId.int
+    genDisplayName c, symId
+  gen c, t, n
+
+proc genGlobal(c: var GeneratedCode; t: Tree; name, typ: NodePos; annotation: string) =
+  c.add annotation
+  let m: string
+  if t[name].kind == SymDef:
+    let symId = t[name].symId
+    m = c.tokens[mangleModuleName(c, c.m.namespace)] & "__" & $symId
+    genDisplayName c, symId
+  else:
+    assert t[name].kind == ModuleSymUse
+    let (x, y) = sons2(t, name)
+    m = c.tokens[mangleModuleName(c, t[x].litId)] & "__" & $t[y].immediateVal
+  genType c, c.m.types, c.m.lit, t[typ].typeId, m
+
+proc genLocal(c: var GeneratedCode; t: Tree; name, typ: NodePos; annotation: string) =
+  assert t[name].kind == SymDef
+  c.add annotation
+  let symId = t[name].symId
+  genType c, c.m.types, c.m.lit, t[typ].typeId, "q" & $symId
+  genDisplayName c, symId
+
+proc genProcDecl(c: var GeneratedCode; t: Tree; n: NodePos; isExtern: bool) =
+  let signatureBegin = c.code.len
+  let name = n.firstSon
+
+  var prc = n.firstSon
+  next t, prc
+
+  while true:
+    case t[prc].kind
+    of PragmaPair:
+      let (x, y) = sons2(t, prc)
+      let key = cast[PragmaKey](t[x].rawOperand)
+      case key
+      of HeaderImport:
+        let lit = t[y].litId
+        let headerAsStr {.cursor.} = c.m.lit.strings[lit]
+        let header = c.tokens.getOrIncl(headerAsStr)
+        # headerAsStr can be empty, this has the semantics of the `nodecl` pragma:
+        if headerAsStr.len > 0 and not c.includedHeaders.containsOrIncl(int header):
+          if headerAsStr[0] == '#':
+            discard "skip the #include"
+          else:
+            c.includes.add Token(IncludeKeyword)
+          c.includes.add header
+          c.includes.add Token NewLine
+        # do not generate code for importc'ed procs:
+        return
+      of DllImport:
+        let lit = t[y].litId
+        raiseAssert "cannot eval: " & c.m.lit.strings[lit]
+      else: discard
+    of PragmaId: discard
+    else: break
+    next t, prc
+
+  var resultDeclPos = NodePos(-1)
+  if t[prc].kind == SummonResult:
+    resultDeclPos = prc
+    gen c, t, prc.firstSon
+    next t, prc
+  else:
+    c.add "void"
+  c.add Space
+  genSymDef c, t, name
+  c.add ParLe
+  var params = 0
+  while t[prc].kind == SummonParam:
+    if params > 0: c.add Comma
+    let (typ, sym) = sons2(t, prc)
+    genLocal c, t, sym, typ, ""
+    next t, prc
+    inc params
+  if params == 0:
+    c.add "void"
+  c.add ParRi
+
+  for i in signatureBegin ..< c.code.len:
+    c.protos.add c.code[i]
+  c.protos.add Token Semicolon
+
+  if isExtern:
+    c.code.setLen signatureBegin
+  else:
+    c.add CurlyLe
+    if resultDeclPos.int >= 0:
+      gen c, t, resultDeclPos
+    for ch in sonsRest(t, n, prc):
+      gen c, t, ch
+    c.add CurlyRi
+
+template triop(opr) =
+  let (typ, a, b) = sons3(t, n)
+  c.add ParLe
+  c.add ParLe
+  gen c, t, typ
+  c.add ParRi
+  gen c, t, a
+  c.add opr
+  gen c, t, b
+  c.add ParRi
+
+template cmpop(opr) =
+  let (_, a, b) = sons3(t, n)
+  c.add ParLe
+  gen c, t, a
+  c.add opr
+  gen c, t, b
+  c.add ParRi
+
+template binaryop(opr) =
+  let (typ, a) = sons2(t, n)
+  c.add ParLe
+  c.add ParLe
+  gen c, t, typ
+  c.add ParRi
+  c.add opr
+  gen c, t, a
+  c.add ParRi
+
+template checkedBinaryop(opr) =
+  let (typ, labIdx, a, b) = sons4(t, n)
+  let bits = integralBits(c.m.types[t[typ].typeId])
+  let lab = t[labIdx].label
+
+  c.add (opr & $bits)
+  c.add ParLe
+  c.gen t, a
+  c.add Comma
+  c.gen t, b
+  c.add Comma
+  c.add "L" & $lab.int
+  c.add ParRi
+
+proc genNumberConv(c: var GeneratedCode; t: Tree; n: NodePos) =
+  let (typ, arg) = sons2(t, n)
+  if t[arg].kind == IntVal:
+    let litId = t[arg].litId
+    c.add ParLe
+    c.add ParLe
+    gen c, t, typ
+    c.add ParRi
+    case c.m.types[t[typ].typeId].kind
+    of UIntTy:
+      let x = cast[uint64](c.m.lit.numbers[litId])
+      c.add $x
+    of FloatTy:
+      let x = cast[float64](c.m.lit.numbers[litId])
+      c.add $x
+    else:
+      gen c, t, arg
+    c.add ParRi
+  else:
+    binaryop ""
+
+template moveToDataSection(body: untyped) =
+  let oldLen = c.code.len
+  body
+  for i in oldLen ..< c.code.len:
+    c.data.add c.code[i]
+  setLen c.code, oldLen
+
+proc gen(c: var GeneratedCode; t: Tree; n: NodePos) =
+  case t[n].kind
+  of Nop:
+    discard "nothing to emit"
+  of ImmediateVal:
+    c.add $t[n].immediateVal
+  of IntVal:
+    genIntLit c, c.m.lit, t[n].litId
+  of StrVal:
+    c.code.add genStrLit(c, c.m.lit, t[n].litId)
+  of Typed:
+    genType c, c.m.types, c.m.lit, t[n].typeId
+  of SymDef, SymUse:
+    let s = t[n].symId
+    if c.needsPrefix.contains(s.int):
+      c.code.add mangleModuleName(c, c.m.namespace)
+      c.add "__"
+      c.add $s
+    else:
+      # XXX Use proper names here
+      c.add "q"
+      c.add $s
+
+  of ModuleSymUse:
+    let (x, y) = sons2(t, n)
+    let u = mangleModuleName(c, t[x].litId)
+    let s = t[y].immediateVal
+    c.code.add u
+    c.add "__"
+    c.add $s
+
+  of NilVal:
+    c.add NullPtr
+  of LoopLabel:
+    c.add WhileKeyword
+    c.add ParLe
+    c.add "1"
+    c.add ParRi
+    c.add CurlyLe
+  of GotoLoop:
+    c.add CurlyRi
+  of Label:
+    let lab = t[n].label
+    c.add "L"
+    c.add $lab.int
+    c.add Colon
+    c.add Semicolon
+  of Goto:
+    let lab = t[n].label
+    c.add "goto L"
+    c.add $lab.int
+    c.add Semicolon
+  of CheckedGoto:
+    discard "XXX todo"
+  of ArrayConstr:
+    c.add CurlyLe
+    c.add ".a = "
+    c.add CurlyLe
+    var i = 0
+    for ch in sonsFrom1(t, n):
+      if i > 0: c.add Comma
+      c.gen t, ch
+      inc i
+    c.add CurlyRi
+    c.add CurlyRi
+  of ObjConstr:
+    c.add CurlyLe
+    var i = 0
+    for ch in sonsFrom1(t, n):
+      if i mod 2 == 0:
+        if i > 0: c.add Comma
+        c.add ".F" & $t[ch].immediateVal
+        c.add AsgnOpr
+      else:
+        c.gen t, ch
+      inc i
+    c.add CurlyRi
+  of Ret:
+    c.add ReturnKeyword
+    c.gen t, n.firstSon
+    c.add Semicolon
+  of Select:
+    c.add SwitchKeyword
+    c.add ParLe
+    let (_, selector) = sons2(t, n)
+    c.gen t, selector
+    c.add ParRi
+    c.add CurlyLe
+    for ch in sonsFromN(t, n, 2):
+      c.gen t, ch
+    c.add CurlyRi
+  of SelectPair:
+    let (le, ri) = sons2(t, n)
+    c.gen t, le
+    c.gen t, ri
+  of SelectList:
+    for ch in sons(t, n):
+      c.gen t, ch
+  of SelectValue:
+    c.add CaseKeyword
+    c.gen t, n.firstSon
+    c.add Colon
+  of SelectRange:
+    let (le, ri) = sons2(t, n)
+    c.add CaseKeyword
+    c.gen t, le
+    c.add " ... "
+    c.gen t, ri
+    c.add Colon
+  of ForeignDecl:
+    c.data.add LitId(ExternKeyword)
+    c.gen t, n.firstSon
+  of SummonGlobal:
+    moveToDataSection:
+      let (typ, sym) = sons2(t, n)
+      c.genGlobal t, sym, typ, ""
+      c.add Semicolon
+  of SummonThreadLocal:
+    moveToDataSection:
+      let (typ, sym) = sons2(t, n)
+      c.genGlobal t, sym, typ, "__thread "
+      c.add Semicolon
+  of SummonConst:
+    moveToDataSection:
+      let (typ, sym, val) = sons3(t, n)
+      c.genGlobal t, sym, typ, "const "
+      c.add AsgnOpr
+      c.gen t, val
+      c.add Semicolon
+  of Summon, SummonResult:
+    let (typ, sym) = sons2(t, n)
+    c.genLocal t, sym, typ, ""
+    c.add Semicolon
+
+  of SummonParam:
+    raiseAssert "SummonParam should have been handled in genProc"
+  of Kill:
+    discard "we don't care about Kill instructions"
+  of AddrOf:
+    let (_, arg) = sons2(t, n)
+    c.add "&"
+    gen c, t, arg
+  of DerefArrayAt:
+    let (_, a, i) = sons3(t, n)
+    gen c, t, a
+    c.add BracketLe
+    gen c, t, i
+    c.add BracketRi
+  of ArrayAt:
+    let (_, a, i) = sons3(t, n)
+    gen c, t, a
+    c.add Dot
+    c.add "a"
+    c.add BracketLe
+    gen c, t, i
+    c.add BracketRi
+  of FieldAt:
+    let (_, a, b) = sons3(t, n)
+    gen c, t, a
+    let field = t[b].immediateVal
+    c.add Dot
+    c.add "F" & $field
+  of DerefFieldAt:
+    let (_, a, b) = sons3(t, n)
+    gen c, t, a
+    let field = t[b].immediateVal
+    c.add Arrow
+    c.add "F" & $field
+  of Load:
+    let (_, arg) = sons2(t, n)
+    c.add ParLe
+    c.add "*"
+    gen c, t, arg
+    c.add ParRi
+  of Store:
+    raiseAssert "Assumption was that Store is unused!"
+  of Asgn:
+    let (_, dest, src) = sons3(t, n)
+    gen c, t, dest
+    c.add AsgnOpr
+    gen c, t, src
+    c.add Semicolon
+  of CheckedRange:
+    c.add "nimCheckRange"
+    c.add ParLe
+    let (_, gotoInstr, x, a, b) = sons5(t, n)
+    gen c, t, x
+    c.add Comma
+    gen c, t, a
+    c.add Comma
+    gen c, t, b
+    c.add Comma
+    c.add "L" & $t[gotoInstr].label.int
+    c.add ParRi
+  of CheckedIndex:
+    c.add "nimCheckIndex"
+    c.add ParLe
+    let (gotoInstr, x, a) = sons3(t, n)
+    gen c, t, x
+    c.add Comma
+    gen c, t, a
+    c.add Comma
+    c.add "L" & $t[gotoInstr].label.int
+    c.add ParRi
+  of Call, IndirectCall:
+    let (typ, fn) = sons2(t, n)
+    gen c, t, fn
+    c.add ParLe
+    var i = 0
+    for ch in sonsFromN(t, n, 2):
+      if i > 0: c.add Comma
+      gen c, t, ch
+      inc i
+    c.add ParRi
+    if c.m.types[t[typ].typeId].kind == VoidTy:
+      c.add Semicolon
+  of CheckedCall, CheckedIndirectCall:
+    let (typ, gotoInstr, fn) = sons3(t, n)
+    gen c, t, fn
+    c.add ParLe
+    var i = 0
+    for ch in sonsFromN(t, n, 3):
+      if i > 0: c.add Comma
+      gen c, t, ch
+      inc i
+    c.add ParRi
+    if c.m.types[t[typ].typeId].kind == VoidTy:
+      c.add Semicolon
+
+  of CheckedAdd: checkedBinaryop "nimAddInt"
+  of CheckedSub: checkedBinaryop "nimSubInt"
+  of CheckedMul: checkedBinaryop "nimMulInt"
+  of CheckedDiv: checkedBinaryop "nimDivInt"
+  of CheckedMod: checkedBinaryop "nimModInt"
+  of Add: triop " + "
+  of Sub: triop " - "
+  of Mul: triop " * "
+  of Div: triop " / "
+  of Mod: triop " % "
+  of BitShl: triop " << "
+  of BitShr: triop " >> "
+  of BitAnd: triop " & "
+  of BitOr: triop " | "
+  of BitXor: triop " ^ "
+  of BitNot: binaryop " ~ "
+  of BoolNot: binaryop " !"
+  of Eq: cmpop " == "
+  of Le: cmpop " <= "
+  of Lt: cmpop " < "
+  of Cast: binaryop ""
+  of NumberConv: genNumberConv c, t, n
+  of CheckedObjConv: binaryop ""
+  of ObjConv: binaryop ""
+  of Emit: raiseAssert "cannot interpret: Emit"
+  of ProcDecl: genProcDecl c, t, n, false
+  of ForeignProcDecl: genProcDecl c, t, n, true
+  of PragmaPair, PragmaId, TestOf, Yld, SetExc, TestExc:
+    c.add "cannot interpret: " & $t[n].kind
+
+const
+  Prelude = """
+/* GENERATED CODE. DO NOT EDIT. */
+
+#ifdef __cplusplus
+#define NB8 bool
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901)
+// see #13798: to avoid conflicts for code emitting `#include <stdbool.h>`
+#define NB8 _Bool
+#else
+typedef unsigned char NB8; // best effort
+#endif
+
+typedef unsigned char NC8;
+
+typedef float NF32;
+typedef double NF64;
+#if defined(__BORLANDC__) || defined(_MSC_VER)
+typedef signed char NI8;
+typedef signed short int NI16;
+typedef signed int NI32;
+typedef __int64 NI64;
+/* XXX: Float128? */
+typedef unsigned char NU8;
+typedef unsigned short int NU16;
+typedef unsigned int NU32;
+typedef unsigned __int64 NU64;
+#elif defined(HAVE_STDINT_H)
+#ifndef USE_NIM_NAMESPACE
+#  include <stdint.h>
+#endif
+typedef int8_t NI8;
+typedef int16_t NI16;
+typedef int32_t NI32;
+typedef int64_t NI64;
+typedef uint8_t NU8;
+typedef uint16_t NU16;
+typedef uint32_t NU32;
+typedef uint64_t NU64;
+#elif defined(HAVE_CSTDINT)
+#ifndef USE_NIM_NAMESPACE
+#  include <cstdint>
+#endif
+typedef std::int8_t NI8;
+typedef std::int16_t NI16;
+typedef std::int32_t NI32;
+typedef std::int64_t NI64;
+typedef std::uint8_t NU8;
+typedef std::uint16_t NU16;
+typedef std::uint32_t NU32;
+typedef std::uint64_t NU64;
+#else
+/* Unknown compiler/version, do our best */
+#ifdef __INT8_TYPE__
+typedef __INT8_TYPE__ NI8;
+#else
+typedef signed char NI8;
+#endif
+#ifdef __INT16_TYPE__
+typedef __INT16_TYPE__ NI16;
+#else
+typedef signed short int NI16;
+#endif
+#ifdef __INT32_TYPE__
+typedef __INT32_TYPE__ NI32;
+#else
+typedef signed int NI32;
+#endif
+#ifdef __INT64_TYPE__
+typedef __INT64_TYPE__ NI64;
+#else
+typedef long long int NI64;
+#endif
+/* XXX: Float128? */
+#ifdef __UINT8_TYPE__
+typedef __UINT8_TYPE__ NU8;
+#else
+typedef unsigned char NU8;
+#endif
+#ifdef __UINT16_TYPE__
+typedef __UINT16_TYPE__ NU16;
+#else
+typedef unsigned short int NU16;
+#endif
+#ifdef __UINT32_TYPE__
+typedef __UINT32_TYPE__ NU32;
+#else
+typedef unsigned int NU32;
+#endif
+#ifdef __UINT64_TYPE__
+typedef __UINT64_TYPE__ NU64;
+#else
+typedef unsigned long long int NU64;
+#endif
+#endif
+
+#ifdef NIM_INTBITS
+#  if NIM_INTBITS == 64
+typedef NI64 NI;
+typedef NU64 NU;
+#  elif NIM_INTBITS == 32
+typedef NI32 NI;
+typedef NU32 NU;
+#  elif NIM_INTBITS == 16
+typedef NI16 NI;
+typedef NU16 NU;
+#  elif NIM_INTBITS == 8
+typedef NI8 NI;
+typedef NU8 NU;
+#  else
+#    error "invalid bit width for int"
+#  endif
+#endif
+
+#define NIM_STRLIT_FLAG ((NU)(1) << ((NIM_INTBITS) - 2)) /* This has to be the same as system.strlitFlag! */
+
+#define nimAddInt64(a, b, L) ({long long int res; if(__builtin_saddll_overflow(a, b, &res)) goto L; res})
+#define nimSubInt64(a, b, L) ({long long int res; if(__builtin_ssubll_overflow(a, b, &res)) goto L; res})
+#define nimMulInt64(a, b, L) ({long long int res; if(__builtin_smulll_overflow(a, b, &res)) goto L; res})
+
+#define nimAddInt32(a, b, L) ({long int res; if(__builtin_sadd_overflow(a, b, &res)) goto L; res})
+#define nimSubInt32(a, b, L) ({long int res; if(__builtin_ssub_overflow(a, b, &res)) goto L; res})
+#define nimMulInt32(a, b, L) ({long int res; if(__builtin_smul_overflow(a, b, &res)) goto L; res})
+
+#define nimCheckRange(x, a, b, L) ({if (x < a || x > b) goto L; x})
+#define nimCheckIndex(x, a, L) ({if (x >= a) goto L; x})
+
+"""
+
+proc traverseCode(c: var GeneratedCode) =
+  const AllowedInToplevelC = {SummonConst, SummonGlobal, SummonThreadLocal,
+                              ProcDecl, ForeignDecl, ForeignProcDecl}
+  var i = NodePos(0)
+  while i.int < c.m.code.len:
+    let oldLen = c.code.len
+    let moveToInitSection = c.m.code[NodePos(i)].kind notin AllowedInToplevelC
+
+    gen c, c.m.code, NodePos(i)
+    next c.m.code, i
+
+    if moveToInitSection:
+      for i in oldLen ..< c.code.len:
+        c.init.add c.code[i]
+      setLen c.code, oldLen
+
+proc generateCode*(inp, outp: string) =
+  var c = initGeneratedCode(load(inp))
+
+  var co = TypeOrder()
+  traverseTypes(c.m.types, c.m.lit, co)
+
+  generateTypes(c, c.m.types, c.m.lit, co)
+  let typeDecls = move c.code
+
+  traverseCode c
+  var f = CppFile(f: open(outp, fmWrite))
+  f.write "#define NIM_INTBITS " & $c.m.intbits & "\n"
+  f.write Prelude
+  writeTokenSeq f, c.includes, c
+  writeTokenSeq f, typeDecls, c
+  writeTokenSeq f, c.data, c
+  writeTokenSeq f, c.protos, c
+  writeTokenSeq f, c.code, c
+  if c.init.len > 0:
+    f.write "void __attribute__((constructor)) init(void) {"
+    writeTokenSeq f, c.init, c
+    f.write "}\n\n"
+  f.f.close

compiler/nir/nir.nim

@@ -0,0 +1,105 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Nim Intermediate Representation, designed to capture all of Nim's semantics without losing too much
+## precious information. Can easily be translated into C. And to JavaScript, hopefully.
+
+from std/os import addFileExt, `/`, createDir
+
+import std / assertions
+import ".." / [ast, modulegraphs, renderer, transf, options, msgs, lineinfos]
+import nirtypes, nirinsts, ast2ir, nirlineinfos, nirfiles, nirvm
+
+import ".." / ic / [rodfiles, bitabs]
+
+type
+  PCtx* = ref object of TPassContext
+    m: ModuleCon
+    c: ProcCon
+    oldErrorCount: int
+    bytecode: Bytecode
+
+proc newCtx*(module: PSym; g: ModuleGraph; idgen: IdGenerator): PCtx =
+  var lit = Literals()
+  var nirm = (ref NirModule)(types: initTypeGraph(lit), lit: lit)
+  var m = initModuleCon(g, g.config, idgen, module, nirm)
+  m.noModularity = true
+  PCtx(m: m, c: initProcCon(m, nil, g.config), idgen: idgen, bytecode: initBytecode(nirm))
+
+proc refresh*(c: PCtx; module: PSym; idgen: IdGenerator) =
+  #c.m = initModuleCon(c.m.graph, c.m.graph.config, idgen, module, c.m.nirm)
+  #c.m.noModularity = true
+  c.c = initProcCon(c.m, nil, c.m.graph.config)
+  c.idgen = idgen
+
+proc setupGlobalCtx*(module: PSym; graph: ModuleGraph; idgen: IdGenerator) =
+  if graph.repl.isNil:
+    graph.repl = newCtx(module, graph, idgen)
+    #registerAdditionalOps(PCtx graph.repl)
+  else:
+    refresh(PCtx graph.repl, module, idgen)
+
+proc setupNirReplGen*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext =
+  setupGlobalCtx(module, graph, idgen)
+  result = PCtx graph.repl
+
+proc evalStmt(c: PCtx; n: PNode) =
+  let n = transformExpr(c.m.graph, c.idgen, c.m.module, n)
+  let pc = genStmt(c.c, n)
+  #var res = ""
+  #toString c.m.nirm.code, NodePos(pc), c.m.nirm.lit.strings, c.m.nirm.lit.numbers, c.m.symnames, res
+  #res.add "\n--------------------------\n"
+  #toString res, c.m.types.g
+  if pc.int < c.m.nirm.code.len:
+    c.bytecode.interactive = c.m.graph.interactive
+    execCode c.bytecode, c.m.nirm.code, pc
+  #echo res
+
+proc runCode*(c: PPassContext; n: PNode): PNode =
+  let c = PCtx(c)
+  # don't eval errornous code:
+  if c.oldErrorCount == c.m.graph.config.errorCounter:
+    evalStmt(c, n)
+    result = newNodeI(nkEmpty, n.info)
+  else:
+    result = n
+  c.oldErrorCount = c.m.graph.config.errorCounter
+
+type
+  NirPassContext* = ref object of TPassContext
+    m: ModuleCon
+    c: ProcCon
+
+proc openNirBackend*(g: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext =
+  var lit = Literals()
+  var nirm = (ref NirModule)(types: initTypeGraph(lit), lit: lit)
+  let m = initModuleCon(g, g.config, idgen, module, nirm)
+  NirPassContext(m: m, c: initProcCon(m, nil, g.config), idgen: idgen)
+
+proc gen(c: NirPassContext; n: PNode) =
+  let n = transformExpr(c.m.graph, c.idgen, c.m.module, n)
+  let pc = genStmt(c.c, n)
+
+proc nirBackend*(c: PPassContext; n: PNode): PNode =
+  gen(NirPassContext(c), n)
+  result = n
+
+proc closeNirBackend*(c: PPassContext; finalNode: PNode) =
+  discard nirBackend(c, finalNode)
+
+  let c = NirPassContext(c)
+  let nimcache = getNimcacheDir(c.c.config).string
+  createDir nimcache
+  let outp = nimcache / c.m.module.name.s.addFileExt("nir")
+  #c.m.nirm.code = move c.c.code
+  try:
+    store c.m.nirm[], outp
+    echo "created: ", outp
+  except IOError:
+    rawMessage(c.c.config, errFatal, "serialization failed: " & outp)

compiler/nir/nirc.nim

@@ -0,0 +1,52 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Nir Compiler.
+
+import ".." / ic / [bitabs, rodfiles]
+import nirinsts, nirtypes, nirlineinfos, nirfiles, cir
+
+proc view(filename: string) =
+  let m = load(filename)
+  var res = ""
+  allTreesToString m.code, m.lit.strings, m.lit.numbers, m.symnames, res
+  res.add "\n# TYPES\n"
+  nirtypes.toString res, m.types
+  echo res
+
+import std / [syncio, parseopt]
+
+proc writeHelp =
+  echo """Usage: nirc view|c <file.nir>"""
+  quit 0
+
+proc main =
+  var inp = ""
+  var cmd = ""
+  for kind, key, val in getopt():
+    case kind
+    of cmdArgument:
+      if cmd.len == 0: cmd = key
+      elif inp.len == 0: inp = key
+      else: quit "Error: too many arguments"
+    of cmdLongOption, cmdShortOption:
+      case key
+      of "help", "h": writeHelp()
+      of "version", "v": stdout.write "1.0\n"
+    of cmdEnd: discard
+  if inp.len == 0:
+    quit "Error: no input file specified"
+  case cmd
+  of "", "view":
+    view inp
+  of "c":
+    let outp = inp & ".c"
+    cir.generateCode inp, outp
+
+main()

compiler/nir/nirfiles.nim

@@ -0,0 +1,83 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import ".." / ic / [bitabs, rodfiles]
+import nirinsts, nirtypes, nirlineinfos
+
+type
+  NirModule* = object
+    code*: Tree
+    man*: LineInfoManager
+    types*: TypeGraph
+    lit*: Literals
+    namespace*: LitId
+    intbits*: uint32
+    symnames*: SymNames
+
+proc load*(filename: string): NirModule =
+  let lit = Literals()
+  result = NirModule(lit: lit, types: initTypeGraph(lit))
+  var r = rodfiles.open(filename)
+  try:
+    r.loadHeader(nirCookie)
+    r.loadSection stringsSection
+    r.load result.lit.strings
+
+    r.loadSection numbersSection
+    r.load result.lit.numbers
+
+    r.loadSection bodiesSection
+    r.load result.code
+
+    r.loadSection typesSection
+    r.load result.types
+
+    r.loadSection sideChannelSection
+    r.load result.man
+
+    r.loadSection namespaceSection
+    r.loadPrim result.namespace
+    r.loadPrim result.intbits
+
+    r.loadSection symnamesSection
+    r.load result.symnames
+
+  finally:
+    r.close()
+
+proc store*(m: NirModule; outp: string) =
+  var r = rodfiles.create(outp)
+  try:
+    r.storeHeader(nirCookie)
+    r.storeSection stringsSection
+    r.store m.lit.strings
+
+    r.storeSection numbersSection
+    r.store m.lit.numbers
+
+    r.storeSection bodiesSection
+    r.store m.code
+
+    r.storeSection typesSection
+    r.store m.types
+
+    r.storeSection sideChannelSection
+    r.store m.man
+
+    r.storeSection namespaceSection
+    r.storePrim m.namespace
+    r.storePrim m.intbits
+
+    r.storeSection symnamesSection
+    r.store m.symnames
+
+  finally:
+    r.close()
+  if r.err != ok:
+    raise newException(IOError, "could store into: " & outp)

compiler/nir/nirinsts.nim

@@ -0,0 +1,582 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## NIR instructions. Somewhat inspired by LLVM's instructions.
+
+import std / [assertions, hashes]
+import .. / ic / [bitabs, rodfiles]
+import nirlineinfos, nirtypes
+
+const
+  NirVersion = 1
+  nirCookie* = [byte(0), byte('N'), byte('I'), byte('R'),
+            byte(sizeof(int)*8), byte(system.cpuEndian), byte(0), byte(NirVersion)]
+
+type
+  SymId* = distinct int
+
+proc `$`*(s: SymId): string {.borrow.}
+proc hash*(s: SymId): Hash {.borrow.}
+proc `==`*(a, b: SymId): bool {.borrow.}
+
+type
+  Opcode* = enum
+    Nop,
+    ImmediateVal,
+    IntVal,
+    StrVal,
+    SymDef,
+    SymUse,
+    Typed,   # with type ID
+    PragmaId, # with Pragma ID, possible values: see PragmaKey enum
+    NilVal,
+    Label,
+    Goto,
+    CheckedGoto,
+    LoopLabel,
+    GotoLoop,  # last atom
+
+    ModuleSymUse, # `"module".x`
+
+    ArrayConstr,
+    ObjConstr,
+    Ret,
+    Yld,
+
+    Select,
+    SelectPair,  # ((values...), Label)
+    SelectList,  # (values...)
+    SelectValue, # (value)
+    SelectRange, # (valueA..valueB)
+    ForeignDecl, # Can wrap SummonGlobal, SummonThreadLocal, SummonConst
+    SummonGlobal,
+    SummonThreadLocal,
+    Summon, # x = Summon Typed <Type ID>; x begins to live
+    SummonResult,
+    SummonParam,
+    SummonConst,
+    Kill, # `Kill x`: scope end for `x`
+
+    AddrOf,
+    ArrayAt, # a[i]
+    DerefArrayAt, # a[i] where `a` is a PtrArray; `a[][i]`
+    FieldAt, # obj.field
+    DerefFieldAt, # obj[].field
+
+    Load, # a[]
+    Store, # a[] = b
+    Asgn,  # a = b
+    SetExc,
+    TestExc,
+
+    CheckedRange,
+    CheckedIndex,
+
+    Call,
+    IndirectCall,
+    CheckedCall, # call that can raise
+    CheckedIndirectCall, # call that can raise
+    CheckedAdd, # with overflow checking etc.
+    CheckedSub,
+    CheckedMul,
+    CheckedDiv,
+    CheckedMod,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    BitShl,
+    BitShr,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+    BoolNot,
+    Eq,
+    Le,
+    Lt,
+    Cast,
+    NumberConv,
+    CheckedObjConv,
+    ObjConv,
+    TestOf,
+    Emit,
+    ProcDecl,
+    ForeignProcDecl,
+    PragmaPair
+
+type
+  PragmaKey* = enum
+    FastCall, StdCall, CDeclCall, SafeCall, SysCall, InlineCall, NoinlineCall, ThisCall, NoCall,
+    CoreName,
+    ExternName,
+    HeaderImport,
+    DllImport,
+    DllExport,
+    ObjExport
+
+const
+  LastAtomicValue = GotoLoop
+
+  OpcodeBits = 8'u32
+  OpcodeMask = (1'u32 shl OpcodeBits) - 1'u32
+
+  ValueProducingAtoms = {ImmediateVal, IntVal, StrVal, SymUse, NilVal}
+
+  ValueProducing* = {
+    ImmediateVal,
+    IntVal,
+    StrVal,
+    SymUse,
+    NilVal,
+    ModuleSymUse,
+    ArrayConstr,
+    ObjConstr,
+    CheckedAdd,
+    CheckedSub,
+    CheckedMul,
+    CheckedDiv,
+    CheckedMod,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    BitShl,
+    BitShr,
+    BitAnd,
+    BitOr,
+    BitXor,
+    BitNot,
+    BoolNot,
+    Eq,
+    Le,
+    Lt,
+    Cast,
+    NumberConv,
+    CheckedObjConv,
+    ObjConv,
+    AddrOf,
+    Load,
+    ArrayAt,
+    DerefArrayAt,
+    FieldAt,
+    DerefFieldAt,
+    TestOf
+  }
+
+type
+  Instr* = object     # 8 bytes
+    x: uint32
+    info*: PackedLineInfo
+
+template kind*(n: Instr): Opcode = Opcode(n.x and OpcodeMask)
+template operand(n: Instr): uint32 = (n.x shr OpcodeBits)
+
+template rawOperand*(n: Instr): uint32 = (n.x shr OpcodeBits)
+
+template toX(k: Opcode; operand: uint32): uint32 =
+  uint32(k) or (operand shl OpcodeBits)
+
+template toX(k: Opcode; operand: LitId): uint32 =
+  uint32(k) or (operand.uint32 shl OpcodeBits)
+
+type
+  Tree* = object
+    nodes: seq[Instr]
+
+  Values* = object
+    numbers: BiTable[int64]
+    strings: BiTable[string]
+
+type
+  PatchPos* = distinct int
+  NodePos* = distinct int
+
+const
+  InvalidPatchPos* = PatchPos(-1)
+
+proc isValid(p: PatchPos): bool {.inline.} = p.int != -1
+
+proc prepare*(tree: var Tree; info: PackedLineInfo; kind: Opcode): PatchPos =
+  result = PatchPos tree.nodes.len
+  tree.nodes.add Instr(x: toX(kind, 1'u32), info: info)
+
+proc isAtom(tree: Tree; pos: int): bool {.inline.} = tree.nodes[pos].kind <= LastAtomicValue
+proc isAtom(tree: Tree; pos: NodePos): bool {.inline.} = tree.nodes[pos.int].kind <= LastAtomicValue
+
+proc patch*(tree: var Tree; pos: PatchPos) =
+  let pos = pos.int
+  let k = tree.nodes[pos].kind
+  assert k > LastAtomicValue
+  let distance = int32(tree.nodes.len - pos)
+  assert distance > 0
+  tree.nodes[pos].x = toX(k, cast[uint32](distance))
+
+template build*(tree: var Tree; info: PackedLineInfo; kind: Opcode; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  body
+  patch(tree, pos)
+
+template buildTyped*(tree: var Tree; info: PackedLineInfo; kind: Opcode; typ: TypeId; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  tree.addTyped info, typ
+  body
+  patch(tree, pos)
+
+proc len*(tree: Tree): int {.inline.} = tree.nodes.len
+
+template rawSpan(n: Instr): int = int(operand(n))
+
+proc nextChild(tree: Tree; pos: var int) {.inline.} =
+  if tree.nodes[pos].kind > LastAtomicValue:
+    assert tree.nodes[pos].operand > 0'u32
+    inc pos, tree.nodes[pos].rawSpan
+  else:
+    inc pos
+
+proc next*(tree: Tree; pos: var NodePos) {.inline.} = nextChild tree, int(pos)
+
+template firstSon*(n: NodePos): NodePos = NodePos(n.int+1)
+
+template skipTyped*(n: NodePos): NodePos = NodePos(n.int+2)
+
+iterator sons*(tree: Tree; n: NodePos): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+iterator sonsFrom1*(tree: Tree; n: NodePos): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  nextChild tree, pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+iterator sonsFromN*(tree: Tree; n: NodePos; toSkip = 2): NodePos =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  for i in 1..toSkip:
+    nextChild tree, pos
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+template `[]`*(t: Tree; n: NodePos): Instr = t.nodes[n.int]
+
+iterator sonsRest*(tree: Tree; parent, n: NodePos): NodePos =
+  var pos = n.int
+  assert tree[parent].kind > LastAtomicValue
+  let last = parent.int + tree[parent].rawSpan
+  while pos < last:
+    yield NodePos pos
+    nextChild tree, pos
+
+proc span(tree: Tree; pos: int): int {.inline.} =
+  if tree.nodes[pos].kind <= LastAtomicValue: 1 else: int(tree.nodes[pos].operand)
+
+proc copyTree*(dest: var Tree; src: Tree) =
+  let pos = 0
+  let L = span(src, pos)
+  let d = dest.nodes.len
+  dest.nodes.setLen(d + L)
+  assert L > 0
+  for i in 0..<L:
+    dest.nodes[d+i] = src.nodes[pos+i]
+
+proc sons2*(tree: Tree; n: NodePos): (NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  result = (NodePos a, NodePos b)
+
+proc sons3*(tree: Tree; n: NodePos): (NodePos, NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  result = (NodePos a, NodePos b, NodePos c)
+
+proc sons4*(tree: Tree; n: NodePos): (NodePos, NodePos, NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  let d = c + span(tree, c)
+  result = (NodePos a, NodePos b, NodePos c, NodePos d)
+
+proc sons5*(tree: Tree; n: NodePos): (NodePos, NodePos, NodePos, NodePos, NodePos) {.inline.} =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  let d = c + span(tree, c)
+  let e = d + span(tree, d)
+  result = (NodePos a, NodePos b, NodePos c, NodePos d, NodePos e)
+
+proc typeId*(ins: Instr): TypeId {.inline.} =
+  assert ins.kind == Typed
+  result = TypeId(ins.operand)
+
+proc symId*(ins: Instr): SymId {.inline.} =
+  assert ins.kind in {SymUse, SymDef}
+  result = SymId(ins.operand)
+
+proc immediateVal*(ins: Instr): int {.inline.} =
+  assert ins.kind == ImmediateVal
+  result = cast[int](ins.operand)
+
+proc litId*(ins: Instr): LitId {.inline.} =
+  assert ins.kind in {StrVal, IntVal}
+  result = LitId(ins.operand)
+
+
+type
+  LabelId* = distinct int
+
+proc `==`*(a, b: LabelId): bool {.borrow.}
+proc hash*(a: LabelId): Hash {.borrow.}
+
+proc label*(ins: Instr): LabelId {.inline.} =
+  assert ins.kind in {Label, LoopLabel, Goto, GotoLoop, CheckedGoto}
+  result = LabelId(ins.operand)
+
+proc newLabel*(labelGen: var int): LabelId {.inline.} =
+  result = LabelId labelGen
+  inc labelGen
+
+proc newLabels*(labelGen: var int; n: int): LabelId {.inline.} =
+  result = LabelId labelGen
+  inc labelGen, n
+
+proc addNewLabel*(t: var Tree; labelGen: var int; info: PackedLineInfo; k: Opcode): LabelId =
+  assert k in {Label, LoopLabel}
+  result = LabelId labelGen
+  t.nodes.add Instr(x: toX(k, uint32(result)), info: info)
+  inc labelGen
+
+proc gotoLabel*(t: var Tree; info: PackedLineInfo; k: Opcode; L: LabelId) =
+  assert k in {Goto, GotoLoop, CheckedGoto}
+  t.nodes.add Instr(x: toX(k, uint32(L)), info: info)
+
+proc addLabel*(t: var Tree; info: PackedLineInfo; k: Opcode; L: LabelId) {.inline.} =
+  assert k in {Label, LoopLabel, Goto, GotoLoop, CheckedGoto}
+  t.nodes.add Instr(x: toX(k, uint32(L)), info: info)
+
+proc addSymUse*(t: var Tree; info: PackedLineInfo; s: SymId) {.inline.} =
+  t.nodes.add Instr(x: toX(SymUse, uint32(s)), info: info)
+
+proc addSymDef*(t: var Tree; info: PackedLineInfo; s: SymId) {.inline.} =
+  t.nodes.add Instr(x: toX(SymDef, uint32(s)), info: info)
+
+proc addNop*(t: var Tree; info: PackedLineInfo) {.inline.} =
+  t.nodes.add Instr(x: toX(Nop, 0'u32), info: info)
+
+proc addTyped*(t: var Tree; info: PackedLineInfo; typ: TypeId) {.inline.} =
+  assert typ.int >= 0
+  t.nodes.add Instr(x: toX(Typed, uint32(typ)), info: info)
+
+proc addSummon*(t: var Tree; info: PackedLineInfo; s: SymId; typ: TypeId; opc = Summon) {.inline.} =
+  assert typ.int >= 0
+  assert opc in {Summon, SummonConst, SummonGlobal, SummonThreadLocal, SummonParam, SummonResult}
+  let x = prepare(t, info, opc)
+  t.nodes.add Instr(x: toX(Typed, uint32(typ)), info: info)
+  t.nodes.add Instr(x: toX(SymDef, uint32(s)), info: info)
+  patch t, x
+
+proc addImmediateVal*(t: var Tree; info: PackedLineInfo; x: int) =
+  assert x >= 0 and x < ((1 shl 32) - OpcodeBits.int)
+  t.nodes.add Instr(x: toX(ImmediateVal, uint32(x)), info: info)
+
+proc addPragmaId*(t: var Tree; info: PackedLineInfo; x: PragmaKey) =
+  t.nodes.add Instr(x: toX(PragmaId, uint32(x)), info: info)
+
+proc addIntVal*(t: var Tree; integers: var BiTable[int64]; info: PackedLineInfo; typ: TypeId; x: int64) =
+  buildTyped t, info, NumberConv, typ:
+    t.nodes.add Instr(x: toX(IntVal, uint32(integers.getOrIncl(x))), info: info)
+
+proc boolVal*(t: var Tree; integers: var BiTable[int64]; info: PackedLineInfo; b: bool) =
+  buildTyped t, info, NumberConv, Bool8Id:
+    t.nodes.add Instr(x: toX(IntVal, uint32(integers.getOrIncl(ord b))), info: info)
+
+proc addStrVal*(t: var Tree; strings: var BiTable[string]; info: PackedLineInfo; s: string) =
+  t.nodes.add Instr(x: toX(StrVal, uint32(strings.getOrIncl(s))), info: info)
+
+proc addStrLit*(t: var Tree; info: PackedLineInfo; s: LitId) =
+  t.nodes.add Instr(x: toX(StrVal, uint32(s)), info: info)
+
+proc addNilVal*(t: var Tree; info: PackedLineInfo; typ: TypeId) =
+  buildTyped t, info, NumberConv, typ:
+    t.nodes.add Instr(x: toX(NilVal, uint32(0)), info: info)
+
+proc store*(r: var RodFile; t: Tree) = storeSeq r, t.nodes
+proc load*(r: var RodFile; t: var Tree) = loadSeq r, t.nodes
+
+proc escapeToNimLit*(s: string; result: var string) =
+  result.add '"'
+  for c in items s:
+    if c < ' ' or int(c) >= 128:
+      result.add '\\'
+      result.addInt int(c)
+    elif c == '\\':
+      result.add r"\\"
+    elif c == '\n':
+      result.add r"\n"
+    elif c == '\r':
+      result.add r"\r"
+    elif c == '\t':
+      result.add r"\t"
+    else:
+      result.add c
+  result.add '"'
+
+type
+  SymNames* = object
+    s: seq[LitId]
+
+proc `[]=`*(t: var SymNames; key: SymId; val: LitId) =
+  let k = int(key)
+  if k >= t.s.len: t.s.setLen k+1
+  t.s[k] = val
+
+proc `[]`*(t: SymNames; key: SymId): LitId =
+  let k = int(key)
+  if k < t.s.len: result = t.s[k]
+  else: result = LitId(0)
+
+template localName(s: SymId): string =
+  let name = names[s]
+  if name != LitId(0):
+    strings[name]
+  else:
+    $s.int
+
+proc store*(r: var RodFile; t: SymNames) = storeSeq(r, t.s)
+proc load*(r: var RodFile; t: var SymNames) = loadSeq(r, t.s)
+
+proc toString*(t: Tree; pos: NodePos; strings: BiTable[string]; integers: BiTable[int64];
+               names: SymNames;
+               r: var string; nesting = 0) =
+  if r.len > 0 and r[r.len-1] notin {' ', '\n', '(', '[', '{'}:
+    r.add ' '
+
+  case t[pos].kind
+  of Nop: r.add "Nop"
+  of ImmediateVal:
+    r.add $t[pos].operand
+  of IntVal:
+    r.add "IntVal "
+    r.add $integers[LitId t[pos].operand]
+  of StrVal:
+    escapeToNimLit(strings[LitId t[pos].operand], r)
+  of SymDef:
+    r.add "SymDef "
+    r.add localName(SymId t[pos].operand)
+  of SymUse:
+    r.add "SymUse "
+    r.add localName(SymId t[pos].operand)
+  of PragmaId:
+    r.add $cast[PragmaKey](t[pos].operand)
+  of Typed:
+    r.add "T<"
+    r.add $t[pos].operand
+    r.add ">"
+  of NilVal:
+    r.add "NilVal"
+  of Label:
+    # undo the nesting:
+    var spaces = r.len-1
+    while spaces >= 0 and r[spaces] == ' ': dec spaces
+    r.setLen spaces+1
+    r.add "\n  L"
+    r.add $t[pos].operand
+  of Goto, CheckedGoto, LoopLabel, GotoLoop:
+    r.add $t[pos].kind
+    r.add " L"
+    r.add $t[pos].operand
+  else:
+    r.add $t[pos].kind
+    r.add "{\n"
+    for i in 0..<(nesting+1)*2: r.add ' '
+    for p in sons(t, pos):
+      toString t, p, strings, integers, names, r, nesting+1
+    r.add "\n"
+    for i in 0..<nesting*2: r.add ' '
+    r.add "}"
+
+proc allTreesToString*(t: Tree; strings: BiTable[string]; integers: BiTable[int64];
+                       names: SymNames;
+                       r: var string) =
+  var i = 0
+  while i < t.len:
+    toString t, NodePos(i), strings, integers, names, r
+    nextChild t, i
+
+type
+  Value* = distinct Tree
+
+proc prepare*(dest: var Value; info: PackedLineInfo; k: Opcode): PatchPos {.inline.} =
+  assert k in ValueProducing - ValueProducingAtoms
+  result = prepare(Tree(dest), info, k)
+
+proc patch*(dest: var Value; pos: PatchPos) {.inline.} =
+  patch(Tree(dest), pos)
+
+proc localToValue*(info: PackedLineInfo; s: SymId): Value =
+  result = Value(Tree())
+  Tree(result).addSymUse info, s
+
+proc hasValue*(v: Value): bool {.inline.} = Tree(v).len > 0
+
+proc isEmpty*(v: Value): bool {.inline.} = Tree(v).len == 0
+
+proc extractTemp*(v: Value): SymId =
+  if hasValue(v) and Tree(v)[NodePos 0].kind == SymUse:
+    result = SymId(Tree(v)[NodePos 0].operand)
+  else:
+    result = SymId(-1)
+
+proc copyTree*(dest: var Tree; src: Value) = copyTree dest, Tree(src)
+
+proc addImmediateVal*(t: var Value; info: PackedLineInfo; x: int) =
+  assert x >= 0 and x < ((1 shl 32) - OpcodeBits.int)
+  Tree(t).nodes.add Instr(x: toX(ImmediateVal, uint32(x)), info: info)
+
+template build*(tree: var Value; info: PackedLineInfo; kind: Opcode; body: untyped) =
+  let pos = prepare(Tree(tree), info, kind)
+  body
+  patch(tree, pos)
+
+proc addTyped*(t: var Value; info: PackedLineInfo; typ: TypeId) {.inline.} =
+  addTyped(Tree(t), info, typ)
+
+template buildTyped*(tree: var Value; info: PackedLineInfo; kind: Opcode; typ: TypeId; body: untyped) =
+  let pos = prepare(tree, info, kind)
+  tree.addTyped info, typ
+  body
+  patch(tree, pos)
+
+proc addStrVal*(t: var Value; strings: var BiTable[string]; info: PackedLineInfo; s: string) =
+  addStrVal(Tree(t), strings, info, s)
+
+proc addNilVal*(t: var Value; info: PackedLineInfo; typ: TypeId) =
+  addNilVal Tree(t), info, typ
+
+proc addIntVal*(t: var Value; integers: var BiTable[int64]; info: PackedLineInfo; typ: TypeId; x: int64) =
+  addIntVal Tree(t), integers, info, typ, x

compiler/nir/nirlineinfos.nim

@@ -1,7 +1,7 @@
 #
 #
 #           The Nim Compiler
-#        (c) Copyright 2024 Andreas Rumpf
+#        (c) Copyright 2023 Andreas Rumpf
 #
 #    See the file "copying.txt", included in this
 #    distribution, for details about the copyright.

compiler/nir/nirslots.nim

@@ -0,0 +1,104 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Management of slots. Similar to "register allocation"
+## in lower level languages.
+
+import std / [assertions, tables]
+import nirtypes, nirinsts
+
+type
+  SlotManagerFlag* = enum
+    ReuseTemps,
+    ReuseVars
+  SlotKind* = enum
+    Temp, Perm
+  SlotManager* = object # "register allocator"
+    live: Table[SymId, (SlotKind, TypeId)]
+    dead: Table[TypeId, seq[SymId]]
+    flags: set[SlotManagerFlag]
+    inScope: seq[SymId]
+
+proc initSlotManager*(flags: set[SlotManagerFlag]): SlotManager {.inline.} =
+  SlotManager(flags: flags)
+
+proc allocRaw(m: var SlotManager; t: TypeId; f: SlotManagerFlag; k: SlotKind;
+              symIdgen: var int32): SymId {.inline.} =
+  if f in m.flags and m.dead.hasKey(t) and m.dead[t].len > 0:
+    result = m.dead[t].pop()
+  else:
+    inc symIdgen
+    result = SymId(symIdgen)
+    m.inScope.add result
+  m.live[result] = (k, t)
+
+proc allocTemp*(m: var SlotManager; t: TypeId; symIdgen: var int32): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseTemps, Temp, symIdgen)
+
+proc allocVar*(m: var SlotManager; t: TypeId; symIdgen: var int32): SymId {.inline.} =
+  result = allocRaw(m, t, ReuseVars, Perm, symIdgen)
+
+proc freeLoc*(m: var SlotManager; s: SymId) =
+  let t = m.live.getOrDefault(s)
+  assert t[1].int != 0
+  m.live.del s
+  m.dead.mgetOrPut(t[1], @[]).add s
+
+proc freeTemp*(m: var SlotManager; s: SymId) =
+  let t = m.live.getOrDefault(s)
+  if t[1].int != 0 and t[0] == Temp:
+    m.live.del s
+    m.dead.mgetOrPut(t[1], @[]).add s
+
+iterator stillAlive*(m: SlotManager): (SymId, TypeId) =
+  for k, v in pairs(m.live):
+    yield (k, v[1])
+
+proc getType*(m: SlotManager; s: SymId): TypeId {.inline.} = m.live[s][1]
+
+proc openScope*(m: var SlotManager) =
+  m.inScope.add SymId(-1) # add marker
+
+proc closeScope*(m: var SlotManager) =
+  var i = m.inScope.len - 1
+  while i >= 0:
+    if m.inScope[i] == SymId(-1):
+      m.inScope.setLen i
+      break
+    dec i
+
+when isMainModule:
+  var symIdgen: int32
+  var m = initSlotManager({ReuseTemps})
+
+  var g = initTypeGraph(Literals())
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5
+  let finalArrayType = finishType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.addName "MyType"
+
+  g.addField "p", finalArrayType, 0
+  let objB = finishType(g, obj)
+
+  let x = m.allocTemp(objB, symIdgen)
+  assert x.int == 0
+
+  let y = m.allocTemp(objB, symIdgen)
+  assert y.int == 1
+
+  let z = m.allocTemp(Int8Id, symIdgen)
+  assert z.int == 2
+
+  m.freeLoc y
+  let y2 = m.allocTemp(objB, symIdgen)
+  assert y2.int == 1

compiler/nir/nirtypes.nim

@@ -0,0 +1,475 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## Type system for NIR. Close to C's type system but without its quirks.
+
+import std / [assertions, hashes]
+import .. / ic / [bitabs, rodfiles]
+
+type
+  NirTypeKind* = enum
+    VoidTy, IntTy, UIntTy, FloatTy, BoolTy, CharTy, NameVal,
+    IntVal, SizeVal, AlignVal, OffsetVal,
+    AnnotationVal,
+    ObjectTy,
+    UnionTy,
+    VarargsTy, # the `...` in a C prototype; also the last "atom"
+    APtrTy, # pointer to aliasable memory
+    UPtrTy, # pointer to unique/unaliasable memory
+    AArrayPtrTy, # pointer to array of aliasable memory
+    UArrayPtrTy, # pointer to array of unique/unaliasable memory
+    ArrayTy,
+    LastArrayTy, # array of unspecified size as a last field inside an object
+    ProcTy,
+    ObjectDecl,
+    UnionDecl,
+    FieldDecl
+
+const
+  TypeKindBits = 8'u32
+  TypeKindMask = (1'u32 shl TypeKindBits) - 1'u32
+
+type
+  TypeNode* = object     # 4 bytes
+    x: uint32
+
+template kind*(n: TypeNode): NirTypeKind = NirTypeKind(n.x and TypeKindMask)
+template operand(n: TypeNode): uint32 = (n.x shr TypeKindBits)
+
+proc integralBits*(n: TypeNode): int {.inline.} =
+  # Number of bits in the IntTy, etc. Only valid for integral types.
+  assert n.kind in {IntTy, UIntTy, FloatTy, BoolTy, CharTy}
+  result = int(n.operand)
+
+template toX(k: NirTypeKind; operand: uint32): uint32 =
+  uint32(k) or (operand shl TypeKindBits)
+
+template toX(k: NirTypeKind; operand: LitId): uint32 =
+  uint32(k) or (operand.uint32 shl TypeKindBits)
+
+type
+  TypeId* = distinct int
+
+proc `==`*(a, b: TypeId): bool {.borrow.}
+proc hash*(a: TypeId): Hash {.borrow.}
+
+type
+  Literals* = ref object
+    strings*: BiTable[string]
+    numbers*: BiTable[int64]
+
+  TypeGraph* = object
+    nodes: seq[TypeNode]
+    lit: Literals
+
+const
+  VoidId* = TypeId 0
+  Bool8Id* = TypeId 1
+  Char8Id* = TypeId 2
+  Int8Id* = TypeId 3
+  Int16Id* = TypeId 4
+  Int32Id* = TypeId 5
+  Int64Id* = TypeId 6
+  UInt8Id* = TypeId 7
+  UInt16Id* = TypeId 8
+  UInt32Id* = TypeId 9
+  UInt64Id* = TypeId 10
+  Float32Id* = TypeId 11
+  Float64Id* = TypeId 12
+  VoidPtrId* = TypeId 13
+  LastBuiltinId* = 13
+
+proc initTypeGraph*(lit: Literals): TypeGraph =
+  result = TypeGraph(nodes: @[
+    TypeNode(x: toX(VoidTy, 0'u32)),
+    TypeNode(x: toX(BoolTy, 8'u32)),
+    TypeNode(x: toX(CharTy, 8'u32)),
+    TypeNode(x: toX(IntTy, 8'u32)),
+    TypeNode(x: toX(IntTy, 16'u32)),
+    TypeNode(x: toX(IntTy, 32'u32)),
+    TypeNode(x: toX(IntTy, 64'u32)),
+    TypeNode(x: toX(UIntTy, 8'u32)),
+    TypeNode(x: toX(UIntTy, 16'u32)),
+    TypeNode(x: toX(UIntTy, 32'u32)),
+    TypeNode(x: toX(UIntTy, 64'u32)),
+    TypeNode(x: toX(FloatTy, 32'u32)),
+    TypeNode(x: toX(FloatTy, 64'u32)),
+    TypeNode(x: toX(APtrTy, 2'u32)),
+    TypeNode(x: toX(VoidTy, 0'u32))
+  ], lit: lit)
+  assert result.nodes.len == LastBuiltinId+2
+
+type
+  TypePatchPos* = distinct int
+
+const
+  InvalidTypePatchPos* = TypePatchPos(-1)
+  LastAtomicValue = VarargsTy
+
+proc isValid(p: TypePatchPos): bool {.inline.} = p.int != -1
+
+proc prepare(tree: var TypeGraph; kind: NirTypeKind): TypePatchPos =
+  result = TypePatchPos tree.nodes.len
+  tree.nodes.add TypeNode(x: toX(kind, 1'u32))
+
+proc isAtom(tree: TypeGraph; pos: int): bool {.inline.} = tree.nodes[pos].kind <= LastAtomicValue
+proc isAtom(tree: TypeGraph; pos: TypeId): bool {.inline.} = tree.nodes[pos.int].kind <= LastAtomicValue
+
+proc patch(tree: var TypeGraph; pos: TypePatchPos) =
+  let pos = pos.int
+  let k = tree.nodes[pos].kind
+  assert k > LastAtomicValue
+  let distance = int32(tree.nodes.len - pos)
+  assert distance > 0
+  tree.nodes[pos].x = toX(k, cast[uint32](distance))
+
+proc len*(tree: TypeGraph): int {.inline.} = tree.nodes.len
+
+template rawSpan(n: TypeNode): int = int(operand(n))
+
+proc nextChild(tree: TypeGraph; pos: var int) {.inline.} =
+  if tree.nodes[pos].kind > LastAtomicValue:
+    assert tree.nodes[pos].operand > 0'u32
+    inc pos, tree.nodes[pos].rawSpan
+  else:
+    inc pos
+
+iterator sons*(tree: TypeGraph; n: TypeId): TypeId =
+  var pos = n.int
+  assert tree.nodes[pos].kind > LastAtomicValue
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  while pos < last:
+    yield TypeId pos
+    nextChild tree, pos
+
+template `[]`*(t: TypeGraph; n: TypeId): TypeNode = t.nodes[n.int]
+
+proc elementType*(tree: TypeGraph; n: TypeId): TypeId {.inline.} =
+  assert tree[n].kind in {APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy, ArrayTy, LastArrayTy}
+  result = TypeId(n.int+1)
+
+proc litId*(n: TypeNode): LitId {.inline.} =
+  assert n.kind in {NameVal, IntVal, SizeVal, AlignVal, OffsetVal, AnnotationVal, ObjectTy, UnionTy}
+  result = LitId(n.operand)
+
+proc kind*(tree: TypeGraph; n: TypeId): NirTypeKind {.inline.} = tree[n].kind
+
+proc span(tree: TypeGraph; pos: int): int {.inline.} =
+  if tree.nodes[pos].kind <= LastAtomicValue: 1 else: int(tree.nodes[pos].operand)
+
+proc sons2(tree: TypeGraph; n: TypeId): (TypeId, TypeId) =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  result = (TypeId a, TypeId b)
+
+proc sons3(tree: TypeGraph; n: TypeId): (TypeId, TypeId, TypeId) =
+  assert(not isAtom(tree, n.int))
+  let a = n.int+1
+  let b = a + span(tree, a)
+  let c = b + span(tree, b)
+  result = (TypeId a, TypeId b, TypeId c)
+
+proc arrayName*(tree: TypeGraph; n: TypeId): TypeId {.inline.} =
+  assert tree[n].kind == ArrayTy
+  let (_, _, c) = sons3(tree, n)
+  result = c
+
+proc arrayLen*(tree: TypeGraph; n: TypeId): BiggestInt =
+  assert tree[n].kind == ArrayTy
+  let (_, b) = sons2(tree, n)
+  result = tree.lit.numbers[LitId tree[b].operand]
+
+proc returnType*(tree: TypeGraph; n: TypeId): (TypeId, TypeId) =
+  # Returns the positions of the return type + calling convention.
+  var pos = n.int
+  assert tree.nodes[pos].kind == ProcTy
+  let a = n.int+1
+  let b = a + span(tree, a)
+  result = (TypeId b, TypeId a) # not a typo, order is reversed
+
+iterator params*(tree: TypeGraph; n: TypeId): TypeId =
+  var pos = n.int
+  assert tree.nodes[pos].kind == ProcTy
+  let last = pos + tree.nodes[pos].rawSpan
+  inc pos
+  nextChild tree, pos
+  nextChild tree, pos
+  while pos < last:
+    yield TypeId pos
+    nextChild tree, pos
+
+proc openType*(tree: var TypeGraph; kind: NirTypeKind): TypePatchPos =
+  assert kind in {APtrTy, UPtrTy, AArrayPtrTy, UArrayPtrTy,
+    ArrayTy, LastArrayTy, ProcTy, ObjectDecl, UnionDecl,
+    FieldDecl}
+  result = prepare(tree, kind)
+
+template typeInvariant(p: TypePatchPos) =
+  when false:
+    if tree[TypeId(p)].kind == FieldDecl:
+      var k = 0
+      for ch in sons(tree, TypeId(p)):
+        inc k
+      assert k > 2, "damn! " & $k
+
+proc sealType*(tree: var TypeGraph; p: TypePatchPos) =
+  patch tree, p
+  typeInvariant(p)
+
+proc finishType*(tree: var TypeGraph; p: TypePatchPos): TypeId =
+  # Search for an existing instance of this type in
+  # order to reduce memory consumption:
+  patch tree, p
+  typeInvariant(p)
+
+  let s = span(tree, p.int)
+  var i = 0
+  while i < p.int:
+    if tree.nodes[i].x == tree.nodes[p.int].x:
+      var isMatch = true
+      for j in 1..<s:
+        if tree.nodes[j+i].x == tree.nodes[j+p.int].x:
+          discard "still a match"
+        else:
+          isMatch = false
+          break
+      if isMatch:
+        if p.int+s == tree.len:
+          setLen tree.nodes, p.int
+        return TypeId(i)
+    nextChild tree, i
+  result = TypeId(p)
+
+proc nominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string): TypeId =
+  assert kind in {ObjectTy, UnionTy}
+  let content = TypeNode(x: toX(kind, tree.lit.strings.getOrIncl(name)))
+  for i in 0..<tree.len:
+    if tree.nodes[i].x == content.x:
+      return TypeId(i)
+  result = TypeId tree.nodes.len
+  tree.nodes.add content
+
+proc addNominalType*(tree: var TypeGraph; kind: NirTypeKind; name: string) =
+  assert kind in {ObjectTy, UnionTy}
+  tree.nodes.add TypeNode(x: toX(kind, tree.lit.strings.getOrIncl(name)))
+
+proc getTypeTag*(tree: TypeGraph; t: TypeId): string =
+  assert tree[t].kind in {ObjectTy, UnionTy}
+  result = tree.lit.strings[LitId tree[t].operand]
+
+proc addVarargs*(tree: var TypeGraph) =
+  tree.nodes.add TypeNode(x: toX(VarargsTy, 0'u32))
+
+proc getFloat128Type*(tree: var TypeGraph): TypeId =
+  result = TypeId tree.nodes.len
+  tree.nodes.add TypeNode(x: toX(FloatTy, 128'u32))
+
+proc addBuiltinType*(g: var TypeGraph; id: TypeId) =
+  g.nodes.add g[id]
+
+template firstSon*(n: TypeId): TypeId = TypeId(n.int+1)
+
+proc addType*(g: var TypeGraph; t: TypeId) =
+  # We cannot simply copy `*Decl` nodes. We have to introduce `*Ty` nodes instead:
+  if g[t].kind in {ObjectDecl, UnionDecl}:
+    assert g[t.firstSon].kind == NameVal
+    let name = LitId g[t.firstSon].operand
+    if g[t].kind == ObjectDecl:
+      g.nodes.add TypeNode(x: toX(ObjectTy, name))
+    else:
+      g.nodes.add TypeNode(x: toX(UnionTy, name))
+  else:
+    let pos = t.int
+    let L = span(g, pos)
+    let d = g.nodes.len
+    g.nodes.setLen(d + L)
+    assert L > 0
+    for i in 0..<L:
+      g.nodes[d+i] = g.nodes[pos+i]
+
+proc addArrayLen*(g: var TypeGraph; len: int64) =
+  g.nodes.add TypeNode(x: toX(IntVal, g.lit.numbers.getOrIncl(len)))
+
+proc addSize*(g: var TypeGraph; s: int64) =
+  g.nodes.add TypeNode(x: toX(SizeVal, g.lit.numbers.getOrIncl(s)))
+
+proc addOffset*(g: var TypeGraph; offset: int64) =
+  g.nodes.add TypeNode(x: toX(OffsetVal, g.lit.numbers.getOrIncl(offset)))
+
+proc addAlign*(g: var TypeGraph; a: int64) =
+  g.nodes.add TypeNode(x: toX(AlignVal, g.lit.numbers.getOrIncl(a)))
+
+proc addName*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl(name)))
+
+proc addAnnotation*(g: var TypeGraph; name: string) =
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl(name)))
+
+proc addField*(g: var TypeGraph; name: string; typ: TypeId; offset: int64) =
+  let f = g.openType FieldDecl
+  g.addType typ
+  g.addOffset offset
+  g.addName name
+  sealType(g, f)
+
+proc ptrTypeOf*(g: var TypeGraph; t: TypeId): TypeId =
+  let f = g.openType APtrTy
+  g.addType t
+  result = finishType(g, f)
+
+proc arrayPtrTypeOf*(g: var TypeGraph; t: TypeId): TypeId =
+  let f = g.openType AArrayPtrTy
+  g.addType t
+  result = finishType(g, f)
+
+proc store*(r: var RodFile; g: TypeGraph) =
+  storeSeq r, g.nodes
+
+proc load*(r: var RodFile; g: var TypeGraph) =
+  loadSeq r, g.nodes
+
+proc toString*(dest: var string; g: TypeGraph; i: TypeId) =
+  case g[i].kind
+  of VoidTy: dest.add "void"
+  of IntTy:
+    dest.add "i"
+    dest.addInt g[i].operand
+  of UIntTy:
+    dest.add "u"
+    dest.addInt g[i].operand
+  of FloatTy:
+    dest.add "f"
+    dest.addInt g[i].operand
+  of BoolTy:
+    dest.add "b"
+    dest.addInt g[i].operand
+  of CharTy:
+    dest.add "c"
+    dest.addInt g[i].operand
+  of NameVal, AnnotationVal:
+    dest.add g.lit.strings[LitId g[i].operand]
+  of IntVal, SizeVal, AlignVal, OffsetVal:
+    dest.add $g[i].kind
+    dest.add ' '
+    dest.add $g.lit.numbers[LitId g[i].operand]
+  of VarargsTy:
+    dest.add "..."
+  of APtrTy:
+    dest.add "aptr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of UPtrTy:
+    dest.add "uptr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of AArrayPtrTy:
+    dest.add "aArrayPtr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of UArrayPtrTy:
+    dest.add "uArrayPtr["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of ArrayTy:
+    dest.add "Array["
+    let (elems, len, name) = g.sons3(i)
+    toString(dest, g, elems)
+    dest.add ", "
+    toString(dest, g, len)
+    dest.add ", "
+    toString(dest, g, name)
+    dest.add "]"
+  of LastArrayTy:
+    # array of unspecified size as a last field inside an object
+    dest.add "LastArrayTy["
+    toString(dest, g, g.elementType(i))
+    dest.add "]"
+  of ObjectTy:
+    dest.add "object "
+    dest.add g.lit.strings[LitId g[i].operand]
+  of UnionTy:
+    dest.add "union "
+    dest.add g.lit.strings[LitId g[i].operand]
+  of ProcTy:
+    dest.add "proc["
+    for t in sons(g, i):
+      dest.add ' '
+      toString(dest, g, t)
+    dest.add "]"
+  of ObjectDecl:
+    dest.add "object["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add '\n'
+    dest.add "]"
+  of UnionDecl:
+    dest.add "union["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add '\n'
+    dest.add "]"
+  of FieldDecl:
+    dest.add "field["
+    for t in sons(g, i):
+      toString(dest, g, t)
+      dest.add ' '
+    dest.add "]"
+
+    when false:
+      let (typ, offset, name) = g.sons3(i)
+      toString(dest, g, typ)
+      dest.add ' '
+      toString(dest, g, offset)
+      dest.add ' '
+      toString(dest, g, name)
+
+proc toString*(dest: var string; g: TypeGraph) =
+  var i = 0
+  while i < g.len:
+    dest.add "T<"
+    dest.addInt i
+    dest.add "> "
+    toString(dest, g, TypeId i)
+    dest.add '\n'
+    nextChild g, i
+
+iterator allTypes*(g: TypeGraph; start = 0): TypeId =
+  var i = start
+  while i < g.len:
+    yield TypeId i
+    nextChild g, i
+
+iterator allTypesIncludingInner*(g: TypeGraph; start = 0): TypeId =
+  var i = start
+  while i < g.len:
+    yield TypeId i
+    inc i
+
+proc `$`(g: TypeGraph): string =
+  result = ""
+  toString(result, g)
+
+when isMainModule:
+  var g = initTypeGraph(Literals())
+
+  let a = g.openType ArrayTy
+  g.addBuiltinType Int8Id
+  g.addArrayLen 5
+  g.addName "SomeArray"
+  let finalArrayType = finishType(g, a)
+
+  let obj = g.openType ObjectDecl
+  g.nodes.add TypeNode(x: toX(NameVal, g.lit.strings.getOrIncl("MyType")))
+
+  g.addField "p", finalArrayType, 0
+  sealType(g, obj)
+
+  echo g

compiler/nir/stringcases.nim

@@ -0,0 +1,200 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## included from ast2ir.nim
+
+#[
+
+case s
+of "abc", "abbd":
+  echo 1
+of "hah":
+  echo 2
+of "gah":
+  echo 3
+
+# we produce code like this:
+
+if s[0] <= 'a':
+  if s == "abc: goto L1
+  elif s == "abbd": goto L1
+else:
+  if s[2] <= 'h':
+    if s == "hah": goto L2
+    elif s == "gah": goto L3
+goto afterCase
+
+L1:
+  echo 1
+  goto afterCase
+L2:
+  echo 2
+  goto afterCase
+L3:
+  echo 3
+  goto afterCase
+
+afterCase: ...
+
+]#
+
+# We split the set of strings into 2 sets of roughly the same size.
+# The condition used for splitting is a (position, char) tuple.
+# Every string of length > position for which s[position] <= char is in one
+# set else it is in the other set.
+
+from std/sequtils import addUnique
+
+type
+  Key = (LitId, LabelId)
+
+proc splitValue(strings: BiTable[string]; a: openArray[Key]; position: int): (char, float) =
+  var cand: seq[char] = @[]
+  for t in items a:
+    let s = strings[t[0]]
+    if s.len > position: cand.addUnique s[position]
+
+  result = ('\0', -1.0)
+  for disc in items cand:
+    var hits = 0
+    for t in items a:
+      let s = strings[t[0]]
+      if s.len > position and s[position] <= disc:
+        inc hits
+    # the split is the better, the more `hits` is close to `a.len / 2`:
+    let grade = 100000.0 - abs(hits.float - a.len.float / 2.0)
+    if grade > result[1]:
+      result = (disc, grade)
+
+proc tryAllPositions(strings: BiTable[string]; a: openArray[Key]): (char, int) =
+  var m = 0
+  for t in items a:
+    m = max(m, strings[t[0]].len)
+
+  result = ('\0', -1)
+  var best = -1.0
+  for i in 0 ..< m:
+    let current = splitValue(strings, a, i)
+    if current[1] > best:
+      best = current[1]
+      result = (current[0], i)
+
+type
+  SearchKind = enum
+    LinearSearch, SplitSearch
+  SearchResult* = object
+    case kind: SearchKind
+    of LinearSearch:
+      a: seq[Key]
+    of SplitSearch:
+      span: int
+      best: (char, int)
+
+proc emitLinearSearch(strings: BiTable[string]; a: openArray[Key]; dest: var seq[SearchResult]) =
+  var d = SearchResult(kind: LinearSearch, a: @[])
+  for x in a: d.a.add x
+  dest.add d
+
+proc split(strings: BiTable[string]; a: openArray[Key]; dest: var seq[SearchResult]) =
+  if a.len <= 4:
+    emitLinearSearch strings, a, dest
+  else:
+    let best = tryAllPositions(strings, a)
+    var groupA: seq[Key] = @[]
+    var groupB: seq[Key] = @[]
+    for t in items a:
+      let s = strings[t[0]]
+      if s.len > best[1] and s[best[1]] <= best[0]:
+        groupA.add t
+      else:
+        groupB.add t
+    if groupA.len == 0 or groupB.len == 0:
+      emitLinearSearch strings, a, dest
+    else:
+      let toPatch = dest.len
+      dest.add SearchResult(kind: SplitSearch, span: 1, best: best)
+      split strings, groupA, dest
+      split strings, groupB, dest
+      let dist = dest.len - toPatch
+      assert dist > 0
+      dest[toPatch].span = dist
+
+proc toProblemDescription(c: var ProcCon; n: PNode): (seq[Key], LabelId) =
+  result = (@[], newLabels(c.labelGen, n.len))
+  assert n.kind == nkCaseStmt
+  for i in 1..<n.len:
+    let it = n[i]
+    let thisBranch = LabelId(result[1].int + i - 1)
+    if it.kind == nkOfBranch:
+      for j in 0..<it.len-1:
+        assert it[j].kind in {nkStrLit..nkTripleStrLit}
+        result[0].add (c.lit.strings.getOrIncl(it[j].strVal), thisBranch)
+
+proc decodeSolution(c: var ProcCon; dest: var Tree; s: seq[SearchResult]; i: int;
+                    selector: Value; info: PackedLineInfo) =
+  case s[i].kind
+  of SplitSearch:
+    let thenA = i+1
+    let elseA = thenA + (if s[thenA].kind == LinearSearch: 1 else: s[thenA].span)
+    let best = s[i].best
+
+    let tmp = getTemp(c, Bool8Id, info)
+    buildTyped dest, info, Asgn, Bool8Id:
+      dest.copyTree tmp
+      buildTyped dest, info, Call, Bool8Id:
+        c.addUseCodegenProc dest, "nimStrAtLe", info
+        dest.copyTree selector
+        dest.addIntVal c.lit.numbers, info, c.m.nativeIntId, best[1]
+        dest.addIntVal c.lit.numbers, info, Char8Id, best[0].int
+
+    template then() =
+      c.decodeSolution dest, s, thenA, selector, info
+    template otherwise() =
+      c.decodeSolution dest, s, elseA, selector, info
+    buildIfThenElse tmp, then, otherwise
+    freeTemp c, tmp
+
+  of LinearSearch:
+    let tmp = getTemp(c, Bool8Id, info)
+    for x in s[i].a:
+      buildTyped dest, info, Asgn, Bool8Id:
+        dest.copyTree tmp
+        buildTyped dest, info, Call, Bool8Id:
+          c.addUseCodegenProc dest, "eqStrings", info
+          dest.copyTree selector
+          dest.addStrLit info, x[0]
+      buildIf tmp:
+        c.code.gotoLabel info, Goto, x[1]
+    freeTemp c, tmp
+
+proc genStringCase(c: var ProcCon; n: PNode; d: var Value) =
+  let (problem, firstBranch) = toProblemDescription(c, n)
+  var solution: seq[SearchResult] = @[]
+  split c.lit.strings, problem, solution
+
+  # XXX Todo move complex case selector into a temporary.
+  let selector = c.genx(n[0])
+
+  let info = toLineInfo(c, n.info)
+  decodeSolution c, c.code, solution, 0, selector, info
+
+  let lend = newLabel(c.labelGen)
+  c.code.addLabel info, Goto, lend
+  for i in 1..<n.len:
+    let it = n[i]
+    let thisBranch = LabelId(firstBranch.int + i - 1)
+    c.code.addLabel info, Label, thisBranch
+    if it.kind == nkOfBranch:
+      gen(c, it.lastSon, d)
+      c.code.addLabel info, Goto, lend
+    else:
+      gen(c, it.lastSon, d)
+
+  c.code.addLabel info, Label, lend
+  freeTemp c, selector

compiler/nir/types2ir.nim

@@ -0,0 +1,525 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2023 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import std / [assertions, tables, sets]
+import ".." / [ast, types, options, sighashes, modulegraphs]
+import nirtypes
+
+type
+  TypesCon* = object
+    processed: Table[ItemId, TypeId]
+    processedByName: Table[string, TypeId]
+    recursionCheck: HashSet[ItemId]
+    conf: ConfigRef
+    stringType: TypeId
+
+proc initTypesCon*(conf: ConfigRef): TypesCon =
+  TypesCon(conf: conf, stringType: TypeId(-1))
+
+proc mangle(c: var TypesCon; t: PType): string =
+  result = $sighashes.hashType(t, c.conf)
+
+template cached(c: var TypesCon; t: PType; body: untyped) =
+  result = c.processed.getOrDefault(t.itemId)
+  if result.int == 0:
+    body
+    c.processed[t.itemId] = result
+
+template cachedByName(c: var TypesCon; t: PType; body: untyped) =
+  let key = mangle(c, t)
+  result = c.processedByName.getOrDefault(key)
+  if result.int == 0:
+    body
+    c.processedByName[key] = result
+
+proc typeToIr*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId
+
+proc collectFieldTypes(c: var TypesCon; g: var TypeGraph; n: PNode; dest: var Table[ItemId, TypeId]) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      collectFieldTypes(c, g, n[i], dest)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    collectFieldTypes(c, g, n[0], dest)
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        collectFieldTypes c, g, lastSon(n[i]), dest
+      else: discard
+  of nkSym:
+    dest[n.sym.itemId] = typeToIr(c, g, n.sym.typ)
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; g: var TypeGraph; n: PNode; fieldTypes: Table[ItemId, TypeId]; unionId: var int) =
+  case n.kind
+  of nkRecList:
+    for i in 0..<n.len:
+      objectToIr(c, g, n[i], fieldTypes, unionId)
+  of nkRecCase:
+    assert(n[0].kind == nkSym)
+    objectToIr(c, g, n[0], fieldTypes, unionId)
+    let u = openType(g, UnionDecl)
+    g.addName "u_" & $unionId
+    inc unionId
+    for i in 1..<n.len:
+      case n[i].kind
+      of nkOfBranch, nkElse:
+        let subObj = openType(g, ObjectDecl)
+        g.addName "uo_" & $unionId & "_" & $i
+        objectToIr c, g, lastSon(n[i]), fieldTypes, unionId
+        sealType(g, subObj)
+      else: discard
+    sealType(g, u)
+  of nkSym:
+    g.addField n.sym.name.s & "_" & $n.sym.position, fieldTypes[n.sym.itemId], n.sym.offset
+  else:
+    assert false, "unknown node kind: " & $n.kind
+
+proc objectToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  if t[0] != nil:
+    # ensure we emitted the base type:
+    discard typeToIr(c, g, t[0])
+
+  var unionId = 0
+  var fieldTypes = initTable[ItemId, TypeId]()
+  collectFieldTypes c, g, t.n, fieldTypes
+  let obj = openType(g, ObjectDecl)
+  g.addName mangle(c, t)
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  if t[0] != nil:
+    g.addNominalType(ObjectTy, mangle(c, t[0]))
+  else:
+    g.addBuiltinType VoidId # object does not inherit
+    if not lacksMTypeField(t):
+      let f2 = g.openType FieldDecl
+      let voidPtr = openType(g, APtrTy)
+      g.addBuiltinType(VoidId)
+      sealType(g, voidPtr)
+      g.addOffset 0 # type field is always at offset 0
+      g.addName "m_type"
+      sealType(g, f2) # FieldDecl
+
+  objectToIr c, g, t.n, fieldTypes, unionId
+  result = finishType(g, obj)
+
+proc objectHeaderToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  result = g.nominalType(ObjectTy, mangle(c, t))
+
+proc tupleToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  var fieldTypes = newSeq[TypeId](t.len)
+  for i in 0..<t.len:
+    fieldTypes[i] = typeToIr(c, g, t[i])
+  let obj = openType(g, ObjectDecl)
+  g.addName mangle(c, t)
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  var accum = OffsetAccum(maxAlign: 1)
+  for i in 0..<t.len:
+    let child = t[i]
+    g.addField "f_" & $i, fieldTypes[i], accum.offset
+
+    computeSizeAlign(c.conf, child)
+    accum.align(child.align)
+    accum.inc(int32(child.size))
+  result = finishType(g, obj)
+
+proc procToIr(c: var TypesCon; g: var TypeGraph; t: PType; addEnv = false): TypeId =
+  var fieldTypes = newSeq[TypeId](0)
+  for i in 0..<t.len:
+    if t[i] == nil or not isCompileTimeOnly(t[i]):
+      fieldTypes.add typeToIr(c, g, t[i])
+  let obj = openType(g, ProcTy)
+
+  case t.callConv
+  of ccNimCall, ccFastCall, ccClosure: g.addAnnotation "__fastcall"
+  of ccStdCall: g.addAnnotation "__stdcall"
+  of ccCDecl: g.addAnnotation "__cdecl"
+  of ccSafeCall: g.addAnnotation "__safecall"
+  of ccSysCall: g.addAnnotation "__syscall"
+  of ccInline: g.addAnnotation "__inline"
+  of ccNoInline: g.addAnnotation "__noinline"
+  of ccThisCall: g.addAnnotation "__thiscall"
+  of ccNoConvention: g.addAnnotation ""
+
+  for i in 0..<fieldTypes.len:
+    g.addType fieldTypes[i]
+
+  if addEnv:
+    let a = openType(g, APtrTy)
+    g.addBuiltinType(VoidId)
+    sealType(g, a)
+
+  if tfVarargs in t.flags:
+    g.addVarargs()
+  result = finishType(g, obj)
+
+proc nativeInt(c: TypesCon): TypeId =
+  case c.conf.target.intSize
+  of 2: result = Int16Id
+  of 4: result = Int32Id
+  else: result = Int64Id
+
+proc openArrayPayloadType*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  let e = lastSon(t)
+  let elementType = typeToIr(c, g, e)
+  let arr = g.openType AArrayPtrTy
+  g.addType elementType
+  result = finishType(g, arr) # LastArrayTy
+
+proc openArrayToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  # object (a: ArrayPtr[T], len: int)
+  let e = lastSon(t)
+  let mangledBase = mangle(c, e)
+  let typeName = "NimOpenArray" & mangledBase
+
+  let elementType = typeToIr(c, g, e)
+  #assert elementType.int >= 0, typeToString(t)
+
+  let p = openType(g, ObjectDecl)
+  g.addName typeName
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  let f = g.openType FieldDecl
+  let arr = g.openType AArrayPtrTy
+  g.addType elementType
+  sealType(g, arr) # LastArrayTy
+  g.addOffset 0
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  g.addField "len", c.nativeInt, c.conf.target.ptrSize
+
+  result = finishType(g, p) # ObjectDecl
+
+proc strPayloadType(c: var TypesCon; g: var TypeGraph): (string, TypeId) =
+  result = ("NimStrPayload", TypeId(-1))
+  let p = openType(g, ObjectDecl)
+  g.addName result[0]
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  g.addField "cap", c.nativeInt, 0
+
+  let f = g.openType FieldDecl
+  let arr = g.openType LastArrayTy
+  g.addBuiltinType Char8Id
+  result[1] = finishType(g, arr) # LastArrayTy
+  g.addOffset c.conf.target.ptrSize # comes after the len field
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  sealType(g, p)
+
+proc strPayloadPtrType*(c: var TypesCon; g: var TypeGraph): (TypeId, TypeId) =
+  let (mangled, arrayType) = strPayloadType(c, g)
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, mangled
+  result = (finishType(g, ffp), arrayType) # APtrTy
+
+proc stringToIr(c: var TypesCon; g: var TypeGraph): TypeId =
+  #[
+
+    NimStrPayload = object
+      cap: int
+      data: UncheckedArray[char]
+
+    NimStringV2 = object
+      len: int
+      p: ptr NimStrPayload
+
+  ]#
+  let payload = strPayloadType(c, g)
+
+  let str = openType(g, ObjectDecl)
+  g.addName "NimStringV2"
+  g.addSize c.conf.target.ptrSize*2
+  g.addAlign c.conf.target.ptrSize
+
+  g.addField "len", c.nativeInt, 0
+
+  let fp = g.openType FieldDecl
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimStrPayload"
+  sealType(g, ffp) # APtrTy
+  g.addOffset c.conf.target.ptrSize # comes after 'len' field
+  g.addName "p"
+  sealType(g, fp) # FieldDecl
+
+  result = finishType(g, str) # ObjectDecl
+
+proc seqPayloadType(c: var TypesCon; g: var TypeGraph; t: PType): (string, TypeId) =
+  #[
+    NimSeqPayload[T] = object
+      cap: int
+      data: UncheckedArray[T]
+  ]#
+  let e = lastSon(t)
+  result = (mangle(c, e), TypeId(-1))
+  let payloadName = "NimSeqPayload" & result[0]
+
+  let elementType = typeToIr(c, g, e)
+
+  let p = openType(g, ObjectDecl)
+  g.addName payloadName
+  g.addSize c.conf.target.intSize
+  g.addAlign c.conf.target.intSize
+
+  g.addField "cap", c.nativeInt, 0
+
+  let f = g.openType FieldDecl
+  let arr = g.openType LastArrayTy
+  g.addType elementType
+  # DO NOT USE `finishType` here as it is an inner type. This is subtle and we
+  # probably need an even better API here.
+  sealType(g, arr)
+  result[1] = TypeId(arr)
+
+  g.addOffset c.conf.target.ptrSize
+  g.addName "data"
+  sealType(g, f) # FieldDecl
+
+  sealType(g, p)
+
+proc seqPayloadPtrType*(c: var TypesCon; g: var TypeGraph; t: PType): (TypeId, TypeId) =
+  let (mangledBase, arrayType) = seqPayloadType(c, g, t)
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  result = (finishType(g, ffp), arrayType) # APtrTy
+
+proc seqToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  #[
+    NimSeqV2*[T] = object
+      len: int
+      p: ptr NimSeqPayload[T]
+  ]#
+  let (mangledBase, _) = seqPayloadType(c, g, t)
+
+  let sq = openType(g, ObjectDecl)
+  g.addName "NimSeqV2" & mangledBase
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  g.addField "len", c.nativeInt, 0
+
+  let fp = g.openType FieldDecl
+  let ffp = g.openType APtrTy
+  g.addNominalType ObjectTy, "NimSeqPayload" & mangledBase
+  sealType(g, ffp) # APtrTy
+  g.addOffset c.conf.target.ptrSize
+  g.addName "p"
+  sealType(g, fp) # FieldDecl
+
+  result = finishType(g, sq) # ObjectDecl
+
+
+proc closureToIr(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  # struct {fn(args, void* env), env}
+  # typedef struct {$n" &
+  #        "N_NIMCALL_PTR($2, ClP_0) $3;$n" &
+  #        "void* ClE_0;$n} $1;$n"
+  let mangledBase = mangle(c, t)
+  let typeName = "NimClosure" & mangledBase
+
+  let procType = procToIr(c, g, t, addEnv=true)
+
+  let p = openType(g, ObjectDecl)
+  g.addName typeName
+  g.addSize c.conf.getSize(t)
+  g.addAlign c.conf.getAlign(t)
+
+  let f = g.openType FieldDecl
+  g.addType procType
+  g.addOffset 0
+  g.addName "ClP_0"
+  sealType(g, f) # FieldDecl
+
+  let f2 = g.openType FieldDecl
+  let voidPtr = openType(g, APtrTy)
+  g.addBuiltinType(VoidId)
+  sealType(g, voidPtr)
+
+  g.addOffset c.conf.target.ptrSize
+  g.addName "ClE_0"
+  sealType(g, f2) # FieldDecl
+
+  result = finishType(g, p) # ObjectDecl
+
+proc bitsetBasetype*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  let s = int(getSize(c.conf, t))
+  case s
+  of 1: result = UInt8Id
+  of 2: result = UInt16Id
+  of 4: result = UInt32Id
+  of 8: result = UInt64Id
+  else: result = UInt8Id
+
+proc typeToIr*(c: var TypesCon; g: var TypeGraph; t: PType): TypeId =
+  if t == nil: return VoidId
+  case t.kind
+  of tyInt:
+    case int(getSize(c.conf, t))
+    of 2: result = Int16Id
+    of 4: result = Int32Id
+    else: result = Int64Id
+  of tyInt8: result = Int8Id
+  of tyInt16: result = Int16Id
+  of tyInt32: result = Int32Id
+  of tyInt64: result = Int64Id
+  of tyFloat:
+    case int(getSize(c.conf, t))
+    of 4: result = Float32Id
+    else: result = Float64Id
+  of tyFloat32: result = Float32Id
+  of tyFloat64: result = Float64Id
+  of tyFloat128: result = getFloat128Type(g)
+  of tyUInt:
+    case int(getSize(c.conf, t))
+    of 2: result = UInt16Id
+    of 4: result = UInt32Id
+    else: result = UInt64Id
+  of tyUInt8: result = UInt8Id
+  of tyUInt16: result = UInt16Id
+  of tyUInt32: result = UInt32Id
+  of tyUInt64: result = UInt64Id
+  of tyBool: result = Bool8Id
+  of tyChar: result = Char8Id
+  of tyVoid: result = VoidId
+  of tySink, tyGenericInst, tyDistinct, tyAlias, tyOwned, tyRange:
+    result = typeToIr(c, g, t.lastSon)
+  of tyEnum:
+    if firstOrd(c.conf, t) < 0:
+      result = Int32Id
+    else:
+      case int(getSize(c.conf, t))
+      of 1: result = UInt8Id
+      of 2: result = UInt16Id
+      of 4: result = Int32Id
+      of 8: result = Int64Id
+      else: result = Int32Id
+  of tyOrdinal, tyGenericBody, tyGenericParam, tyInferred, tyStatic:
+    if t.len > 0:
+      result = typeToIr(c, g, t.lastSon)
+    else:
+      result = TypeId(-1)
+  of tyFromExpr:
+    if t.n != nil and t.n.typ != nil:
+      result = typeToIr(c, g, t.n.typ)
+    else:
+      result = TypeId(-1)
+  of tyArray:
+    cached(c, t):
+      var n = toInt64(lengthOrd(c.conf, t))
+      if n <= 0: n = 1   # make an array of at least one element
+      let elemType = typeToIr(c, g, t[1])
+      let a = openType(g, ArrayTy)
+      g.addType(elemType)
+      g.addArrayLen n
+      g.addName mangle(c, t)
+      result = finishType(g, a)
+  of tyPtr, tyRef:
+    cached(c, t):
+      let e = t.lastSon
+      if e.kind == tyUncheckedArray:
+        let elemType = typeToIr(c, g, e.lastSon)
+        let a = openType(g, AArrayPtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+      else:
+        let elemType = typeToIr(c, g, t.lastSon)
+        let a = openType(g, APtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+  of tyVar, tyLent:
+    cached(c, t):
+      let e = t.lastSon
+      if e.skipTypes(abstractInst).kind in {tyOpenArray, tyVarargs}:
+        # skip the modifier, `var openArray` is a (ptr, len) pair too:
+        result = typeToIr(c, g, e)
+      else:
+        let elemType = typeToIr(c, g, e)
+        let a = openType(g, APtrTy)
+        g.addType(elemType)
+        result = finishType(g, a)
+  of tySet:
+    let s = int(getSize(c.conf, t))
+    case s
+    of 1: result = UInt8Id
+    of 2: result = UInt16Id
+    of 4: result = UInt32Id
+    of 8: result = UInt64Id
+    else:
+      # array[U8, s]
+      cached(c, t):
+        let a = openType(g, ArrayTy)
+        g.addType(UInt8Id)
+        g.addArrayLen s
+        g.addName mangle(c, t)
+        result = finishType(g, a)
+  of tyPointer, tyNil:
+    # tyNil can happen for code like: `const CRAP = nil` which we have in posix.nim
+    let a = openType(g, APtrTy)
+    g.addBuiltinType(VoidId)
+    result = finishType(g, a)
+  of tyObject:
+    # Objects are special as they can be recursive in Nim. This is easily solvable.
+    # We check if we are already "processing" t. If so, we produce `ObjectTy`
+    # instead of `ObjectDecl`.
+    cached(c, t):
+      if not c.recursionCheck.containsOrIncl(t.itemId):
+        result = objectToIr(c, g, t)
+      else:
+        result = objectHeaderToIr(c, g, t)
+  of tyTuple:
+    cachedByName(c, t):
+      result = tupleToIr(c, g, t)
+  of tyProc:
+    cached(c, t):
+      if t.callConv == ccClosure:
+        result = closureToIr(c, g, t)
+      else:
+        result = procToIr(c, g, t)
+  of tyVarargs, tyOpenArray:
+    cached(c, t):
+      result = openArrayToIr(c, g, t)
+  of tyString:
+    if c.stringType.int < 0:
+      result = stringToIr(c, g)
+      c.stringType = result
+    else:
+      result = c.stringType
+  of tySequence:
+    cachedByName(c, t):
+      result = seqToIr(c, g, t)
+  of tyCstring:
+    cached(c, t):
+      let a = openType(g, AArrayPtrTy)
+      g.addBuiltinType Char8Id
+      result = finishType(g, a)
+  of tyUncheckedArray:
+    # We already handled the `ptr UncheckedArray` in a special way.
+    cached(c, t):
+      let elemType = typeToIr(c, g, t.lastSon)
+      let a = openType(g, LastArrayTy)
+      g.addType(elemType)
+      result = finishType(g, a)
+  of tyUntyped, tyTyped:
+    # this avoids a special case for system.echo which is not a generic but
+    # uses `varargs[typed]`:
+    result = VoidId
+  of tyNone, tyEmpty, tyTypeDesc,
+     tyGenericInvocation, tyProxy, tyBuiltInTypeClass,
+     tyUserTypeClass, tyUserTypeClassInst, tyCompositeTypeClass,
+     tyAnd, tyOr, tyNot, tyAnything, tyConcept, tyIterable, tyForward:
+    result = TypeId(-1)

compiler/nodekinds.nim

@@ -1,211 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2015 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## NodeKind enum.
-
-type
-  TNodeKind* = enum # order is extremely important, because ranges are used
-                    # to check whether a node belongs to a certain class
-    nkNone,               # unknown node kind: indicates an error
-                          # Expressions:
-                          # Atoms:
-    nkEmpty,              # the node is empty
-    nkIdent,              # node is an identifier
-    nkSym,                # node is a symbol
-    nkType,               # node is used for its typ field
-
-    nkCharLit,            # a character literal ''
-    nkIntLit,             # an integer literal
-    nkInt8Lit,
-    nkInt16Lit,
-    nkInt32Lit,
-    nkInt64Lit,
-    nkUIntLit,            # an unsigned integer literal
-    nkUInt8Lit,
-    nkUInt16Lit,
-    nkUInt32Lit,
-    nkUInt64Lit,
-    nkFloatLit,           # a floating point literal
-    nkFloat32Lit,
-    nkFloat64Lit,
-    nkFloat128Lit,
-    nkStrLit,             # a string literal ""
-    nkRStrLit,            # a raw string literal r""
-    nkTripleStrLit,       # a triple string literal """
-    nkNilLit,             # the nil literal
-                          # end of atoms
-    nkComesFrom,          # "comes from" template/macro information for
-                          # better stack trace generation
-    nkDotCall,            # used to temporarily flag a nkCall node;
-                          # this is used
-                          # for transforming ``s.len`` to ``len(s)``
-
-    nkCommand,            # a call like ``p 2, 4`` without parenthesis
-    nkCall,               # a call like p(x, y) or an operation like +(a, b)
-    nkCallStrLit,         # a call with a string literal
-                          # x"abc" has two sons: nkIdent, nkRStrLit
-                          # x"""abc""" has two sons: nkIdent, nkTripleStrLit
-    nkInfix,              # a call like (a + b)
-    nkPrefix,             # a call like !a
-    nkPostfix,            # something like a! (also used for visibility)
-    nkHiddenCallConv,     # an implicit type conversion via a type converter
-
-    nkExprEqExpr,         # a named parameter with equals: ''expr = expr''
-    nkExprColonExpr,      # a named parameter with colon: ''expr: expr''
-    nkIdentDefs,          # a definition like `a, b: typeDesc = expr`
-                          # either typeDesc or expr may be nil; used in
-                          # formal parameters, var statements, etc.
-    nkVarTuple,           # a ``var (a, b) = expr`` construct
-    nkPar,                # syntactic (); may be a tuple constructor
-    nkObjConstr,          # object constructor: T(a: 1, b: 2)
-    nkCurly,              # syntactic {}
-    nkCurlyExpr,          # an expression like a{i}
-    nkBracket,            # syntactic []
-    nkBracketExpr,        # an expression like a[i..j, k]
-    nkPragmaExpr,         # an expression like a{.pragmas.}
-    nkRange,              # an expression like i..j
-    nkDotExpr,            # a.b
-    nkCheckedFieldExpr,   # a.b, but b is a field that needs to be checked
-    nkDerefExpr,          # a^
-    nkIfExpr,             # if as an expression
-    nkElifExpr,
-    nkElseExpr,
-    nkLambda,             # lambda expression
-    nkDo,                 # lambda block appering as trailing proc param
-    nkAccQuoted,          # `a` as a node
-
-    nkTableConstr,        # a table constructor {expr: expr}
-    nkBind,               # ``bind expr`` node
-    nkClosedSymChoice,    # symbol choice node; a list of nkSyms (closed)
-    nkOpenSymChoice,      # symbol choice node; a list of nkSyms (open)
-    nkHiddenStdConv,      # an implicit standard type conversion
-    nkHiddenSubConv,      # an implicit type conversion from a subtype
-                          # to a supertype
-    nkConv,               # a type conversion
-    nkCast,               # a type cast
-    nkStaticExpr,         # a static expr
-    nkAddr,               # a addr expression
-    nkHiddenAddr,         # implicit address operator
-    nkHiddenDeref,        # implicit ^ operator
-    nkObjDownConv,        # down conversion between object types
-    nkObjUpConv,          # up conversion between object types
-    nkChckRangeF,         # range check for floats
-    nkChckRange64,        # range check for 64 bit ints
-    nkChckRange,          # range check for ints
-    nkStringToCString,    # string to cstring
-    nkCStringToString,    # cstring to string
-                          # end of expressions
-
-    nkAsgn,               # a = b
-    nkFastAsgn,           # internal node for a fast ``a = b``
-                          # (no string copy)
-    nkGenericParams,      # generic parameters
-    nkFormalParams,       # formal parameters
-    nkOfInherit,          # inherited from symbol
-
-    nkImportAs,           # a 'as' b in an import statement
-    nkProcDef,            # a proc
-    nkMethodDef,          # a method
-    nkConverterDef,       # a converter
-    nkMacroDef,           # a macro
-    nkTemplateDef,        # a template
-    nkIteratorDef,        # an iterator
-
-    nkOfBranch,           # used inside case statements
-                          # for (cond, action)-pairs
-    nkElifBranch,         # used in if statements
-    nkExceptBranch,       # an except section
-    nkElse,               # an else part
-    nkAsmStmt,            # an assembler block
-    nkPragma,             # a pragma statement
-    nkPragmaBlock,        # a pragma with a block
-    nkIfStmt,             # an if statement
-    nkWhenStmt,           # a when expression or statement
-    nkForStmt,            # a for statement
-    nkParForStmt,         # a parallel for statement
-    nkWhileStmt,          # a while statement
-    nkCaseStmt,           # a case statement
-    nkTypeSection,        # a type section (consists of type definitions)
-    nkVarSection,         # a var section
-    nkLetSection,         # a let section
-    nkConstSection,       # a const section
-    nkConstDef,           # a const definition
-    nkTypeDef,            # a type definition
-    nkYieldStmt,          # the yield statement as a tree
-    nkDefer,              # the 'defer' statement
-    nkTryStmt,            # a try statement
-    nkFinally,            # a finally section
-    nkRaiseStmt,          # a raise statement
-    nkReturnStmt,         # a return statement
-    nkBreakStmt,          # a break statement
-    nkContinueStmt,       # a continue statement
-    nkBlockStmt,          # a block statement
-    nkStaticStmt,         # a static statement
-    nkDiscardStmt,        # a discard statement
-    nkStmtList,           # a list of statements
-    nkImportStmt,         # an import statement
-    nkImportExceptStmt,   # an import x except a statement
-    nkExportStmt,         # an export statement
-    nkExportExceptStmt,   # an 'export except' statement
-    nkFromStmt,           # a from * import statement
-    nkIncludeStmt,        # an include statement
-    nkBindStmt,           # a bind statement
-    nkMixinStmt,          # a mixin statement
-    nkUsingStmt,          # an using statement
-    nkCommentStmt,        # a comment statement
-    nkStmtListExpr,       # a statement list followed by an expr; this is used
-                          # to allow powerful multi-line templates
-    nkBlockExpr,          # a statement block ending in an expr; this is used
-                          # to allow powerful multi-line templates that open a
-                          # temporary scope
-    nkStmtListType,       # a statement list ending in a type; for macros
-    nkBlockType,          # a statement block ending in a type; for macros
-                          # types as syntactic trees:
-
-    nkWith,               # distinct with `foo`
-    nkWithout,            # distinct without `foo`
-
-    nkTypeOfExpr,         # type(1+2)
-    nkObjectTy,           # object body
-    nkTupleTy,            # tuple body
-    nkTupleClassTy,       # tuple type class
-    nkTypeClassTy,        # user-defined type class
-    nkStaticTy,           # ``static[T]``
-    nkRecList,            # list of object parts
-    nkRecCase,            # case section of object
-    nkRecWhen,            # when section of object
-    nkRefTy,              # ``ref T``
-    nkPtrTy,              # ``ptr T``
-    nkVarTy,              # ``var T``
-    nkConstTy,            # ``const T``
-    nkOutTy,              # ``out T``
-    nkDistinctTy,         # distinct type
-    nkProcTy,             # proc type
-    nkIteratorTy,         # iterator type
-    nkSinkAsgn,           # '=sink(x, y)'
-    nkEnumTy,             # enum body
-    nkEnumFieldDef,       # `ident = expr` in an enumeration
-    nkArgList,            # argument list
-    nkPattern,            # a special pattern; used for matching
-    nkHiddenTryStmt,      # a hidden try statement
-    nkClosure,            # (prc, env)-pair (internally used for code gen)
-    nkGotoState,          # used for the state machine (for iterators)
-    nkState,              # give a label to a code section (for iterators)
-    nkBreakState,         # special break statement for easier code generation
-    nkFuncDef,            # a func
-    nkTupleConstr         # a tuple constructor
-    nkError               # erroneous AST node
-    nkModuleRef           # for .rod file support: A (moduleId, itemId) pair
-    nkReplayAction        # for .rod file support: A replay action
-    nkNilRodNode          # for .rod file support: a 'nil' PNode
-    nkOpenSym             # container for captured sym that can be overriden by local symbols
-
-const
-  nkCallKinds* = {nkCall, nkInfix, nkPrefix, nkPostfix,
-                  nkCommand, nkCallStrLit, nkHiddenCallConv}

compiler/optimizer.nim

@@ -280,7 +280,7 @@ proc optimize*(n: PNode): PNode =
     Now assume 'use' raises, then we shouldn't do the 'wasMoved(s)'
   ]#
   var c: Con = Con()
-  var b: BasicBlock = default(BasicBlock)
+  var b: BasicBlock
   analyse(c, b, n)
   if c.somethingTodo:
     result = shallowCopy(n)

compiler/options.nim

@@ -25,7 +25,7 @@ const
   useEffectSystem* = true
   useWriteTracking* = false
   hasFFI* = defined(nimHasLibFFI)
-  copyrightYear* = "2024"
+  copyrightYear* = "2023"
 
   nimEnableCovariance* = defined(nimEnableCovariance)
 
@@ -86,7 +86,6 @@ type                          # please make sure we have under 32 options
                               # also: generate header file
     optIdeDebug               # idetools: debug mode
     optIdeTerse               # idetools: use terse descriptions
-    optIdeExceptionInlayHints
     optExcessiveStackTrace    # fully qualified module filenames
     optShowAllMismatches      # show all overloading resolution candidates
     optWholeProject           # for 'doc': output any dependency
@@ -139,6 +138,7 @@ type
     backendCpp = "cpp"
     backendJs = "js"
     backendObjc = "objc"
+    backendNir = "nir"
     # backendNimscript = "nimscript" # this could actually work
     # backendLlvm = "llvm" # probably not well supported; was cmdCompileToLLVM
 
@@ -146,6 +146,7 @@ type
     cmdNone # not yet processed command
     cmdUnknown # command unmapped
     cmdCompileToC, cmdCompileToCpp, cmdCompileToOC, cmdCompileToJS,
+    cmdCompileToNir,
     cmdCrun # compile and run in nimache
     cmdTcc # run the project via TCC backend
     cmdCheck # semantic checking for whole project
@@ -174,11 +175,12 @@ type
 
 const
   cmdBackends* = {cmdCompileToC, cmdCompileToCpp, cmdCompileToOC,
-                  cmdCompileToJS, cmdCrun}
+                  cmdCompileToJS, cmdCrun, cmdCompileToNir}
   cmdDocLike* = {cmdDoc0, cmdDoc, cmdDoc2tex, cmdJsondoc0, cmdJsondoc,
                  cmdCtags, cmdBuildindex}
 
 type
+  NimVer* = tuple[major: int, minor: int, patch: int]
   TStringSeq* = seq[string]
   TGCMode* = enum             # the selected GC
     gcUnselected = "unselected"
@@ -225,11 +227,7 @@ type
     strictDefs,
     strictCaseObjects,
     inferGenericTypes,
-    openSym, # remove nfDisabledOpenSym when this is default
-    # alternative to above:
-    genericsOpenSym
     vtables
-    typeBoundOps
 
   LegacyFeature* = enum
     allowSemcheckedAstModification,
@@ -246,15 +244,13 @@ type
     emitGenerics
       ## generics are emitted in the module that contains them.
       ## Useful for libraries that rely on local passC
-    jsNoLambdaLifting
-      ## Old transformation for closures in JS backend
 
   SymbolFilesOption* = enum
     disabledSf, writeOnlySf, readOnlySf, v2Sf, stressTest
 
   TSystemCC* = enum
     ccNone, ccGcc, ccNintendoSwitch, ccLLVM_Gcc, ccCLang, ccBcc, ccVcc,
-    ccTcc, ccEnv, ccIcl, ccIcc, ccClangCl, ccHipcc, ccNvcc
+    ccTcc, ccEnv, ccIcl, ccIcc, ccClangCl
 
   ExceptionSystem* = enum
     excNone,   # no exception system selected yet
@@ -301,7 +297,6 @@ type
   SuggestInlayHintKind* = enum
     sihkType = "Type",
     sihkParameter = "Parameter"
-    sihkException = "Exception"
 
   SuggestInlayHint* = ref object
     kind*: SuggestInlayHintKind
@@ -370,6 +365,7 @@ type
     arguments*: string ## the arguments to be passed to the program that
                        ## should be run
     ideCmd*: IdeCmd
+    oldNewlines*: bool
     cCompiler*: TSystemCC # the used compiler
     modifiedyNotes*: TNoteKinds # notes that have been set/unset from either cmdline/configs
     cmdlineNotes*: TNoteKinds # notes that have been set/unset from cmdline
@@ -396,7 +392,8 @@ type
     outDir*: AbsoluteDir
     jsonBuildFile*: AbsoluteFile
     prefixDir*, libpath*, nimcacheDir*: AbsoluteDir
-    dllOverrides*, moduleOverrides*, cfileSpecificOptions*: StringTableRef
+    nimStdlibVersion*: NimVer
+    dllOverrides, moduleOverrides*, cfileSpecificOptions*: StringTableRef
     projectName*: string # holds a name like 'nim'
     projectPath*: AbsoluteDir # holds a path like /home/alice/projects/nim/compiler/
     projectFull*: AbsoluteFile # projectPath/projectName
@@ -408,6 +405,7 @@ type
     commandArgs*: seq[string] # any arguments after the main command
     commandLine*: string
     extraCmds*: seq[string] # for writeJsonBuildInstructions
+    keepComments*: bool # whether the parser needs to keep comments
     implicitImports*: seq[string] # modules that are to be implicitly imported
     implicitIncludes*: seq[string] # modules that are to be implicitly included
     docSeeSrcUrl*: string # if empty, no seeSrc will be generated. \
@@ -448,6 +446,16 @@ type
     clientProcessId*: int
 
 
+proc parseNimVersion*(a: string): NimVer =
+  # could be moved somewhere reusable
+  result = default(NimVer)
+  if a.len > 0:
+    let b = a.split(".")
+    assert b.len == 3, a
+    template fn(i) = result[i] = b[i].parseInt # could be optimized if needed
+    fn(0)
+    fn(1)
+    fn(2)
 
 proc assignIfDefault*[T](result: var T, val: T, def = default(T)) =
   ## if `result` was already assigned to a value (that wasn't `def`), this is a noop.
@@ -581,6 +589,7 @@ proc newConfigRef*(): ConfigRef =
     command: "", # the main command (e.g. cc, check, scan, etc)
     commandArgs: @[], # any arguments after the main command
     commandLine: "",
+    keepComments: true, # whether the parser needs to keep comments
     implicitImports: @[], # modules that are to be implicitly imported
     implicitIncludes: @[], # modules that are to be implicitly included
     docSeeSrcUrl: "",
@@ -621,6 +630,12 @@ proc newPartialConfigRef*(): ConfigRef =
 proc cppDefine*(c: ConfigRef; define: string) =
   c.cppDefines.incl define
 
+proc getStdlibVersion*(conf: ConfigRef): NimVer =
+  if conf.nimStdlibVersion == (0,0,0):
+    let s = conf.symbols.getOrDefault("nimVersion", "")
+    conf.nimStdlibVersion = s.parseNimVersion
+  result = conf.nimStdlibVersion
+
 proc isDefined*(conf: ConfigRef; symbol: string): bool =
   if conf.symbols.hasKey(symbol):
     result = true