fixes

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -10,16 +10,6 @@ body:
       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.
 
-- type: textarea
-  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, including the commit hash may help.
-  validations:
-    required: true
-
 - type: textarea
   id: description
   attributes:
@@ -29,6 +19,16 @@ body:
     placeholder: Bug reports with reproducible code or detailed information will be fixed faster.
   validations:
     required: true
+    
+- type: textarea
+  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.
+  validations:
+    required: true
 
 - type: textarea
   id: current-logs

.github/workflows/bisects.yml

@@ -15,16 +15,9 @@ jobs:
     name: ${{ matrix.platform }}-bisects
     runs-on: ${{ matrix.platform }}
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v4
 
-      - name: Install OpenSSL (Windows)
-        if: |
-          runner.os == 'Windows'
-        run: choco install openssl.light --version=1.1.1.0  # OpenSSL 3.x removed SSL_library_init
-        shell: 'powershell'
-
-      # v2 wont work here, because uses "hardcoded" nim versions, action "dynamically" finds version with bug.
-      - uses: jiro4989/setup-nim-action@v1  
+      - uses: jiro4989/setup-nim-action@v1
         with:
           nim-version: 'devel'
 

.github/workflows/ci_docs.yml

@@ -41,11 +41,11 @@ jobs:
         target: [linux, windows, osx]
         include:
           - target: linux
-            os: ubuntu-22.04
+            os: ubuntu-20.04
           - target: windows
-            os: windows-latest
+            os: windows-2019
           - target: osx
-            os: macos-15
+            os: macos-13
 
     name: ${{ matrix.target }}
     runs-on: ${{ matrix.os }}

.github/workflows/ci_gcc14.yml

@@ -0,0 +1,76 @@
+name: GCC 14
+on:
+  pull_request:
+  push:
+    branches:
+      - 'devel'
+
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.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 update -qq
+          sudo apt remove needrestart
+          DEBIAN_FRONTEND='noninteractive' \
+            sudo apt install --no-install-recommends -yq \
+              libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev \
+              valgrind libc6-dbg libblas-dev xorg-dev
+      - name: 'Install dependencies (Linux amd64 gcc 14)'
+        if: runner.os == 'Linux' && matrix.cpu == 'amd64'
+        run: |
+          sudo add-apt-repository universe
+          sudo apt update -qq
+          sudo apt install -y gcc-14 g++-14 libpcre3 liblapack-dev
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 60 --slave /usr/bin/g++ g++ /usr/bin/g++-14
+      - name: 'Install dependencies (macOS)'
+        if: runner.os == 'macOS'
+        run: brew install boehmgc make sfml gtk+3
+      - name: 'Install dependencies (Windows)'
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          set -e
+          . ci/funs.sh
+          nimInternalInstallDepsWindows
+          echo_run echo "${{ github.workspace }}/dist/mingw64/bin" >> "${GITHUB_PATH}"
+
+      - name: 'Add build binaries to PATH'
+        shell: bash
+        run: echo "${{ github.workspace }}/bin" >> "${GITHUB_PATH}"
+
+      - name: 'NIM_TESTAMENT_DISABLE_SSL'
+        shell: bash
+        run: echo "NIM_TESTAMENT_DISABLE_SSL=1" >> $GITHUB_ENV
+
+      - name: 'System information'
+        shell: bash
+        run: . ci/funs.sh && nimCiSystemInfo
+
+      - name: 'Build csourcesAny'
+        shell: bash
+        run: . ci/funs.sh && nimBuildCsourcesIfNeeded CC=gcc ucpu='${{ matrix.cpu }}'
+
+      - name: 'koch, Run CI'
+        shell: bash
+        run: . ci/funs.sh && nimInternalBuildKochAndRunCI

.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,13 +17,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-14]
+        os: [ubuntu-20.04, macos-13]
+        cpu: [amd64]
         batch: ["allowed_failures", "0_3", "1_3", "2_3"] # list of `index_num`
-        include:
-          - os: ubuntu-latest
-            cpu: amd64
-          - os: macos-14
-            cpu: arm64
     name: '${{ matrix.os }} (batch: ${{ matrix.batch }})'
     runs-on: ${{ matrix.os }}
     timeout-minutes: 60 # refs bug #18178
@@ -45,11 +40,11 @@ jobs:
       - name: 'Install dependencies (Linux amd64)'
         if: runner.os == 'Linux' && matrix.cpu == 'amd64'
         run: |
-          sudo apt-get update -qq
+          sudo apt-fast update -qq
           DEBIAN_FRONTEND='noninteractive' \
-            sudo apt-get install --no-install-recommends -yq \
+            sudo apt-fast install --no-install-recommends -yq \
               libcurl4-openssl-dev libgc-dev libsdl1.2-dev libsfml-dev \
-              valgrind libc6-dbg libblas-dev liblapack-dev libpcre3 xorg-dev
+              valgrind libc6-dbg libblas-dev xorg-dev
       - name: 'Install dependencies (macOS)'
         if: runner.os == 'macOS'
         run: brew install boehmgc make sfml gtk+3

.github/workflows/ci_publish.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-22.04]
+        os: [ubuntu-20.04]
         cpu: [amd64]
     name: '${{ matrix.os }}'
     runs-on: ${{ matrix.os }}
@@ -21,10 +21,10 @@ jobs:
         with:
           fetch-depth: 2
 
-      - name: 'Install node.js'
+      - name: 'Install node.js 20.x'
         uses: actions/setup-node@v4
         with:
-          node-version: ''
+          node-version: '20.x'
 
       - name: 'Install dependencies (Linux amd64)'
         if: runner.os == 'Linux' && matrix.cpu == 'amd64'
@@ -34,6 +34,17 @@ jobs:
             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: 'Install dependencies (macOS)'
+        if: runner.os == 'macOS'
+        run: brew install boehmgc make sfml gtk+3
+      - name: 'Install dependencies (Windows)'
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          set -e
+          . ci/funs.sh
+          nimInternalInstallDepsWindows
+          echo_run echo "${{ github.workspace }}/dist/mingw64/bin" >> "${GITHUB_PATH}"
 
       - name: 'Add build binaries to PATH'
         shell: bash

.gitignore

@@ -68,7 +68,6 @@ testament.db
 /csources
 /csources_v1
 /csources_v2
-/csources_v3
 
 /dist/
 # /lib/fusion # fusion is now unbundled; `git status` should reveal if it's there so users can act on it

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:
@@ -28,24 +28,24 @@ jobs:
 #         # g++-multilib : Depends: gcc-multilib (>= 4:5.3.1-1ubuntu1) but it is not going to be installed
 #         vmImage: 'ubuntu-18.04'
 #         CPU: i386
-      OSX_arm64:
-        vmImage: 'macos-15'
-        CPU: arm64
-      OSX_arm64_cpp:
-        vmImage: 'macos-15'
-        CPU: arm64
+      OSX_amd64:
+        vmImage: 'macOS-13'
+        CPU: amd64
+      OSX_amd64_cpp:
+        vmImage: 'macOS-13'
+        CPU: amd64
         NIM_COMPILE_TO_CPP: true
       Windows_amd64_batch0_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         # see also: `NIM_TEST_PACKAGES`
         NIM_TESTAMENT_BATCH: "0_3"
       Windows_amd64_batch1_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         NIM_TESTAMENT_BATCH: "1_3"
       Windows_amd64_batch2_3:
-        vmImage: 'windows-2025'
+        vmImage: 'windows-2019'
         CPU: amd64
         NIM_TESTAMENT_BATCH: "2_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
 

changelog.md

@@ -12,96 +12,22 @@ rounding guarantees (via the
   avoid conflicts with `system.default`, so named argument usage for this
   parameter like `getOrDefault(..., default = ...)` will have to be changed.
 
-- With `-d:nimPreviewCheckedClose`, the `close` function in the `std/syncio` module now raises an IO exception in case of an error.
-
-- Unknown warnings and hints now gives warnings `warnUnknownNotes` instead of
-errors.
-
-- With `-d:nimPreviewAsmSemSymbol`, backticked symbols are type checked in the `asm/emit` statements.
-
-- The bare `except:` now panics on `Defect`. Use `except Exception:` or `except Defect:` to catch `Defect`. `--legacy:noPanicOnExcept` is provided for a transition period.
-
-- With `-d:nimPreviewCStringComparisons`, comparsions (`<`, `>`, `<=`, `>=`) between cstrings switch from reference semantics to value semantics like `==` and `!=`.
-
-- `std/parsesql` has been moved to a nimble package, use `nimble` or `atlas` to install it.
-
-- With `-d:nimPreviewDuplicateModuleError`, importing two modules that share the same name becomes a compile-time error. This includes importing the same module more than once. Use `import foo as foo1` (or other aliases) to avoid collisions.
-
-- Adds the switch `--mangle:nim|cpp`, which selects `nim` or `cpp` style name mangling when used with `debuginfo` on, defaults to `nim`. The default is changed from `cpp` to `nim`.
-
 ## 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.
-- `strutils.multiReplace` overload for character set replacements in a single pass.
-	Useful for string sanitation. Follows existing multiReplace semantics.
-
-- `std/files` adds:
-  - Exports `CopyFlag` enum and `FilePermission` type for fine-grained control of file operations
-  - New file operation procs with `Path` support:
-    - `getFilePermissions`, `setFilePermissions` for managing permissions
-    - `tryRemoveFile` for file deletion
-    - `copyFile` with configurable buffer size and symlink handling
-    - `copyFileWithPermissions` to preserve file attributes
-    - `copyFileToDir` for copying files into directories
-
-- `std/dirs` adds:
-  - New directory operation procs with `Path` support:
-    - `copyDir` with special file handling options
-    - `copyDirWithPermissions` to recursively preserve attributes
-
-- `system.setLenUninit` now supports refc, JS and VM backends.
 
 [//]: # "Changes:"
-
 - `std/math` The `^` symbol now supports floating-point as exponent in addition to the Natural type.
-- `min`, `max`, and `sequtils`' `minIndex`, `maxIndex` and `minmax` for `openArray`s now accept a comparison function.
-- `system.substr` implementation now uses `copymem` (wrapped C `memcpy`) for copying data, if available at compilation.
-- `system.newStringUninit` is now considered free of side-effects allowing it to be used with `--experimental:strictFuncs`.
 
 ## 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.
 
 ## Compiler changes
 
 
 ## Tool changes
 
-- Added `--stdinfile` flag to name of the file used when running program from stdin (defaults to `stdinfile.nim`)
+

changelogs/changelog_0_18_1.md

@@ -53,7 +53,7 @@
   - [``joyent_http_parser``](https://github.com/nim-lang/joyent_http_parser)
 
 - Proc [toCountTable](https://nim-lang.org/docs/tables.html#toCountTable,openArray[A])
-  now produces a `CountTable` with values corresponding to the number of occurrences
+  now produces a `CountTable` with values correspoding to the number of occurrences
   of the key in the input. It used to produce a table with all values set to `1`.
 
   Counting occurrences in a sequence used to be:
@@ -339,7 +339,7 @@ for i in a..b:
 
 - Fixed "ReraiseError when using try/except within finally block"
   ([#5871](https://github.com/nim-lang/Nim/issues/5871))
-- Fixed "Range type inference leads to counter-intuitive behaviour"
+- Fixed "Range type inference leads to counter-intuitive behvaiour"
   ([#5854](https://github.com/nim-lang/Nim/issues/5854))
 - Fixed "JSON % operator can fail in extern procs with dynamic types"
   ([#6385](https://github.com/nim-lang/Nim/issues/6385))
@@ -403,7 +403,7 @@ for i in a..b:
   ([#6589](https://github.com/nim-lang/Nim/issues/6589))
 - Fixed "Generated c code calls function twice"
   ([#6292](https://github.com/nim-lang/Nim/issues/6292))
-- Fixed "Range type inference leads to counter-intuitive behaviour"
+- Fixed "Range type inference leads to counter-intuitive behvaiour"
   ([#5854](https://github.com/nim-lang/Nim/issues/5854))
 - Fixed "New backward indexing is too limited"
   ([#6631](https://github.com/nim-lang/Nim/issues/6631))

changelogs/changelog_1_0_0.md

@@ -22,7 +22,7 @@
 
 - We removed `unicode.Rune16` without any deprecation period as the name
   was wrong (see the [RFC](https://github.com/nim-lang/RFCs/issues/151) for details)
-  and we didn't find any usage of it in the wild. If you still need it, add this
+  and we didn't find any usages of it in the wild. If you still need it, add this
   piece of code to your project:
 ```nim
 type

changelogs/changelog_1_0_2.md

@@ -11,7 +11,7 @@
 * Fixed "Assertion error when running `nim check` on compiler/nim.nim" [#12281](https://github.com/nim-lang/Nim/issues/12281)
 * Fixed "Compiler crash with empty array and generic instantiation with int as parameter" [#12264](https://github.com/nim-lang/Nim/issues/12264)
 * Fixed "Regression in JS backend codegen "Error: request to generate code for .compileTime proc"" [#12240](https://github.com/nim-lang/Nim/issues/12240)
-* Fix how `relativePath` handles case sensitivity
+* Fix how `relativePath` handle case sensitiviy
 * Fixed "SIGSEGV in compiler when using generic types and seqs" [#12336](https://github.com/nim-lang/Nim/issues/12336)
 * Fixed "[1.0.0] weird interaction between `import os` and casting integer to char on macosx trigger bad codegen" [#12291](https://github.com/nim-lang/Nim/issues/12291)
 * VM: no special casing for big endian machines
@@ -43,7 +43,7 @@
 * threadpool: fix link in docs (#12258)
 * Fix spellings (#12277)
 * fix #12278, don't expose internal PCRE documentation
-* Fixed "Documentation of quitprocs is wrong" [#12279](https://github.com/nim-lang/Nim/issues/12279)
+* Fixed "Documentation of quitprocs is wrong" [#12279(https://github.com/nim-lang/Nim/issues/12279)
 * Fix typo in docs
 * Fix reference to parseSpec proc in readme
 * [doc/tut1] removed discard discussion in comments

changelogs/changelog_1_2_0.md

@@ -169,7 +169,7 @@ echo f
 - The Nim compiler now supports a new pragma called ``.localPassc`` to
   pass specific compiler options to the C(++) backend for the C(++) file
   that was produced from the current Nim module.
-- The compiler now infers "sink parameters". To disable this for a specific routine,
+- The compiler now inferes "sink parameters". To disable this for a specific routine,
   annotate it with `.nosinks`. To disable it for a section of code, use
   `{.push sinkInference: off.}`...`{.pop.}`.
 - The compiler now supports a new switch `--panics:on` that turns runtime
@@ -261,7 +261,7 @@ echo f
   ([#12812](https://github.com/nim-lang/Nim/issues/12812))
 - Fixed "Produce static/const initializations for variables when possible"
   ([#12216](https://github.com/nim-lang/Nim/issues/12216))
-- Fixed "Assigning discriminator field leads to internal assert with --gc:destructors"
+- Fixed "Assigning descriminator field leads to internal assert with --gc:destructors"
   ([#12821](https://github.com/nim-lang/Nim/issues/12821))
 - Fixed "nimsuggest `use` command does not return all instances of symbol"
   ([#12832](https://github.com/nim-lang/Nim/issues/12832))

changelogs/changelog_2_0_0.md

@@ -283,7 +283,7 @@ The definition of `"strictFuncs"` was changed.
 The old definition was roughly: "A store to a ref/ptr deref is forbidden unless it's coming from a `var T` parameter".
 The new definition is: "A store to a ref/ptr deref is forbidden."
 
-This new definition is much easier to understand, the price is some expressiveness. The following code used to be
+This new definition is much easier to understand, the price is some expressitivity. The following code used to be
 accepted:
 
 ```nim

compiler/astalgo.nim

@@ -68,6 +68,8 @@ template mdbg*: bool {.deprecated.} =
 # ---------------------------------------------------------------------------
 
 proc lookupInRecord*(n: PNode, field: PIdent): PSym
+proc mustRehash*(length, counter: int): bool
+proc nextTry*(h, maxHash: Hash): Hash {.inline.}
 
 # ------------- table[int, int] ---------------------------------------------
 const
@@ -214,6 +216,10 @@ proc getNamedParamFromList*(list: PNode, ident: PIdent): PSym =
 proc hashNode(p: RootRef): Hash =
   result = hash(cast[pointer](p))
 
+proc mustRehash(length, counter: int): bool =
+  assert(length > counter)
+  result = (length * 2 < counter * 3) or (length - counter < 4)
+
 import std/tables
 
 const backrefStyle = "\e[90m"
@@ -478,6 +484,12 @@ proc debug(n: PNode; conf: ConfigRef) =
   this.value(n)
   echo($this.res)
 
+proc nextTry(h, maxHash: Hash): Hash {.inline.} =
+  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
+  # random-number generation for proof).
+
 proc objectSetContains*(t: TObjectSet, obj: RootRef): bool =
   # returns true whether n is in t
   var h: Hash = hashNode(obj) and high(t.data) # start with real hash value
@@ -525,6 +537,95 @@ proc objectSetContainsOrIncl*(t: var TObjectSet, obj: RootRef): bool =
   inc(t.counter)
   result = false
 
+proc strTableContains*(t: TStrTable, n: PSym): bool =
+  var h: Hash = n.name.h and high(t.data) # start with real hash value
+  while t.data[h] != nil:
+    if (t.data[h] == n):
+      return true
+    h = nextTry(h, high(t.data))
+  result = false
+
+proc strTableRawInsert(data: var seq[PSym], n: PSym) =
+  var h: Hash = n.name.h and high(data)
+  while data[h] != nil:
+    if data[h] == n:
+      # allowed for 'export' feature:
+      #InternalError(n.info, "StrTableRawInsert: " & n.name.s)
+      return
+    h = nextTry(h, high(data))
+  assert(data[h] == nil)
+  data[h] = n
+
+proc symTabReplaceRaw(data: var seq[PSym], prevSym: PSym, newSym: PSym) =
+  assert prevSym.name.h == newSym.name.h
+  var h: Hash = prevSym.name.h and high(data)
+  while data[h] != nil:
+    if data[h] == prevSym:
+      data[h] = newSym
+      return
+    h = nextTry(h, high(data))
+  assert false
+
+proc symTabReplace*(t: var TStrTable, prevSym: PSym, newSym: PSym) =
+  symTabReplaceRaw(t.data, prevSym, newSym)
+
+proc strTableEnlarge(t: var TStrTable) =
+  var n: seq[PSym]
+  newSeq(n, t.data.len * GrowthFactor)
+  for i in 0..high(t.data):
+    if t.data[i] != nil: strTableRawInsert(n, t.data[i])
+  swap(t.data, n)
+
+proc strTableAdd*(t: var TStrTable, n: PSym) =
+  if mustRehash(t.data.len, t.counter): strTableEnlarge(t)
+  strTableRawInsert(t.data, n)
+  inc(t.counter)
+
+proc strTableInclReportConflict*(t: var TStrTable, n: PSym;
+                                 onConflictKeepOld = false): PSym =
+  # if `t` has a conflicting symbol (same identifier as `n`), return it
+  # otherwise return `nil`. Incl `n` to `t` unless `onConflictKeepOld = true`
+  # and a conflict was found.
+  assert n.name != nil
+  var h: Hash = n.name.h and high(t.data)
+  var replaceSlot = -1
+  while true:
+    var it = t.data[h]
+    if it == nil: break
+    # Semantic checking can happen multiple times thanks to templates
+    # and overloading: (var x=@[]; x).mapIt(it).
+    # So it is possible the very same sym is added multiple
+    # times to the symbol table which we allow here with the 'it == n' check.
+    if it.name.id == n.name.id:
+      if it == n: return nil
+      replaceSlot = h
+    h = nextTry(h, high(t.data))
+  if replaceSlot >= 0:
+    result = t.data[replaceSlot] # found it
+    if not onConflictKeepOld:
+      t.data[replaceSlot] = n # overwrite it with newer definition!
+    return result # but return the old one
+  elif mustRehash(t.data.len, t.counter):
+    strTableEnlarge(t)
+    strTableRawInsert(t.data, n)
+  else:
+    assert(t.data[h] == nil)
+    t.data[h] = n
+  inc(t.counter)
+  result = nil
+
+proc strTableIncl*(t: var TStrTable, n: PSym;
+                   onConflictKeepOld = false): bool {.discardable.} =
+  result = strTableInclReportConflict(t, n, onConflictKeepOld) != nil
+
+proc strTableGet*(t: TStrTable, name: PIdent): PSym =
+  var h: Hash = name.h and high(t.data)
+  while true:
+    result = t.data[h]
+    if result == nil: break
+    if result.name.id == name.id: break
+    h = nextTry(h, high(t.data))
+
 
 type
   TIdentIter* = object # iterator over all syms with same identifier
@@ -612,70 +713,6 @@ iterator items*(tab: TStrTable): PSym =
     yield s
     s = nextIter(it, tab)
 
-proc isNil(x: ItemId): bool {.inline.} =
-  x.module == 0 and x.item == 0
-
-proc hasEmptySlot[T](data: TIdPairSeq[T]): bool =
-  for h in 0..high(data):
-    if isNil(data[h].key):
-      return true
-  result = false
-
-proc idTableRawGet[T](t: TIdTable[T], key: int): int =
-  var h: Hash
-  h = key and high(t.data)    # start with real hash value
-  while not isNil(t.data[h].key):
-    if toId(t.data[h].key) == key:
-      return h
-    h = nextTry(h, high(t.data))
-  result = - 1
-
-proc getOrDefault*[T](t: TIdTable[T], key: ItemId): T =
-  var index = idTableRawGet(t, toId(key))
-  if index >= 0: result = t.data[index].val
-  else: result = default(T)
-
-template idTableGet*[T](t: TIdTable[T], key: PType | PSym): T =
-  getOrDefault(t, key.itemId)
-
-proc idTableRawInsert[T](data: var TIdPairSeq[T], key: ItemId, val: T) =
-  var h: Hash
-  let keyId = toId(key)
-  h = keyId and high(data)
-  while not isNil(data[h].key):
-    assert(toId(data[h].key) != keyId)
-    h = nextTry(h, high(data))
-  assert(isNil(data[h].key))
-  data[h].key = key
-  data[h].val = val
-
-proc `[]=`*[T](t: var TIdTable[T], key: ItemId, val: T) =
-  var
-    index: int
-    n: TIdPairSeq[T]
-  index = idTableRawGet(t, toId(key))
-  if index >= 0:
-    assert(not isNil(t.data[index].key))
-    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 not isNil(t.data[i].key):
-          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)
-
-template idTablePut*[T](t: var TIdTable[T], key: PType | PSym, val: T) =
-  t[key.itemId] = val
-
-iterator idTablePairs*[T](t: TIdTable[T]): tuple[key: ItemId, val: T] =
-  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)

compiler/cbuilderbase.nim

@@ -1,164 +1,6 @@
-import ropes, int128
-
 type
-  Snippet* = string
-  Builder* = object
-    buf*: string
-    indents*: int
+  Snippet = string
+  Builder = 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 addNewline*(builder: var Builder) =
-  builder.add('\n')
-  for i in 0 ..< builder.indents:
-    builder.add('\t')
-
-proc addLineEnd*(builder: var Builder, s: string) =
-  builder.add(s)
-  builder.addNewline()
-
-proc addLineEndIndent*(builder: var Builder, s: string) =
-  inc builder.indents
-  builder.add(s)
-  builder.addNewline()
-
-proc addDedent*(builder: var Builder, s: string) =
-  if builder.buf.len > 0 and builder.buf[^1] == '\t':
-    builder.buf.setLen(builder.buf.len - 1)
-  builder.add(s)
-  dec builder.indents
-
-proc addLineEndDedent*(builder: var Builder, s: string) =
-  builder.addDedent(s)
-  builder.addNewline()
-
-proc addLineComment*(builder: var Builder, comment: string) =
-  # probably no-op on nifc
-  builder.add("// ")
-  builder.add(comment)
-  builder.addNewline()
-
-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
-
-template cUintValue*(val: uint): Snippet = $val & "U"
-
-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))
-
-const
-  NimInt* = "NI"
-  NimInt8* = "NI8"
-  NimInt16* = "NI16"
-  NimInt32* = "NI32"
-  NimInt64* = "NI64"
-  CInt* = "int"
-  NimUint* = "NU"
-  NimUint8* = "NU8"
-  NimUint16* = "NU16"
-  NimUint32* = "NU32"
-  NimUint64* = "NU64"
-  NimFloat* = "NF"
-  NimFloat32* = "NF32"
-  NimFloat64* = "NF64"
-  NimFloat128* = "NF128" # not actually defined
-  NimNan* = "NAN"
-  NimInf* = "INF"
-  NimBool* = "NIM_BOOL"
-  NimTrue* = "NIM_TRUE"
-  NimFalse* = "NIM_FALSE"
-  NimChar* = "NIM_CHAR"
-  CChar* = "char"
-  NimCstring* = "NCSTRING"
-  NimNil* = "NIM_NIL"
-  CNil* = "NULL"
-  NimStrlitFlag* = "NIM_STRLIT_FLAG"
-  CVoid* = "void"
-  CPointer* = "void*"
-  CConstPointer* = "NIM_CONST void*"
-
-proc cIntType*(bits: BiggestInt): Snippet =
-  "NI" & $bits
-
-proc cUintType*(bits: BiggestInt): Snippet =
-  "NU" & $bits
-
-type
-  IfBuilderState* = enum
-    WaitingIf, WaitingElseIf, InBlock
-  IfBuilder* = object
-    state*: IfBuilderState
+template newBuilder(s: string): Builder =
+  s

compiler/cbuilderdecls.nim

@@ -32,7 +32,7 @@ proc addVar(builder: var Builder, kind: VarKind = Local, name: string, typ: Snip
   if initializer.len != 0:
     builder.add(" = ")
     builder.add(initializer)
-  builder.addLineEnd(";")
+  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
@@ -40,19 +40,7 @@ template addVarWithType(builder: var Builder, kind: VarKind = Local, name: strin
   body
   builder.add(" ")
   builder.add(name)
-  builder.addLineEnd(";")
-
-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.addLineEnd(";")
+  builder.add(";\n")
 
 template addVarWithTypeAndInitializer(builder: var Builder, kind: VarKind = Local, name: string,
                                       typeBody, initializerBody: typed) =
@@ -64,7 +52,7 @@ template addVarWithTypeAndInitializer(builder: var Builder, kind: VarKind = Loca
   builder.add(name)
   builder.add(" = ")
   initializerBody
-  builder.addLineEnd(";")
+  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
@@ -73,12 +61,12 @@ proc addArrayVar(builder: var Builder, kind: VarKind = Local, name: string, elem
   builder.add(" ")
   builder.add(name)
   builder.add("[")
-  builder.addIntValue(len)
+  builder.addInt(len)
   builder.add("]")
   if initializer.len != 0:
     builder.add(" = ")
     builder.add(initializer)
-  builder.addLineEnd(";")
+  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`
@@ -87,10 +75,10 @@ template addArrayVarWithInitializer(builder: var Builder, kind: VarKind = Local,
   builder.add(" ")
   builder.add(name)
   builder.add("[")
-  builder.addIntValue(len)
+  builder.addInt(len)
   builder.add("] = ")
   body
-  builder.addLineEnd(";")
+  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
@@ -99,20 +87,9 @@ template addTypedef(builder: var Builder, name: string, typeBody: typed) =
   typeBody
   builder.add(" ")
   builder.add(name)
-  builder.addLineEnd(";")
+  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.addLineEnd(";")
-
-template addArrayTypedef(builder: var Builder, name: string, len: BiggestInt, typeBody: typed) =
+template addArrayTypedef(builder: var Builder, name: string, len: int, 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 ")
@@ -120,8 +97,8 @@ template addArrayTypedef(builder: var Builder, name: string, len: BiggestInt, ty
   builder.add(" ")
   builder.add(name)
   builder.add("[")
-  builder.addIntValue(len)
-  builder.addLineEnd("];")
+  builder.addInt(len)
+  builder.add("];\n")
 
 type
   StructInitializerKind = enum
@@ -196,7 +173,7 @@ proc addArrayField(obj: var Builder; name, elementType: Snippet; len: int; initi
   obj.add(" ")
   obj.add(name)
   obj.add("[")
-  obj.addIntValue(len)
+  obj.addInt(len)
   obj.add("]")
   if initializer.len != 0:
     obj.add(initializer)
@@ -207,7 +184,7 @@ proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bo
   obj.add('\t')
   if field.alignment > 0:
     obj.add("NIM_ALIGN(")
-    obj.addIntValue(field.alignment)
+    obj.addInt(field.alignment)
     obj.add(") ")
   obj.add(typ)
   if sfNoalias in field.flags:
@@ -218,21 +195,11 @@ proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bo
     obj.add("[SEQ_DECL_SIZE]")
   if field.bitsize != 0:
     obj.add(":")
-    obj.addIntValue(field.bitsize)
+    obj.addInt(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
@@ -264,14 +231,14 @@ proc startSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Sni
     obj.add(baseType)
   obj.add(" ")
   obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
+  result.preFieldsLen = obj.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:
+  if info.baseKind == bcNone and info.preFieldsLen == obj.len:
     # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = CChar)
+    obj.addField(name = "dummy", typ = "char")
   if info.named:
     obj.add("};\n")
   else:
@@ -320,7 +287,7 @@ proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType:
     obj.add(baseType)
   obj.add(" ")
   obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
+  result.preFieldsLen = obj.len
   case result.baseKind
   of bcNone:
     # rest of the options add a field or don't need it due to inheritance,
@@ -330,7 +297,7 @@ proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType:
         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 = CChar)
+      obj.addField(name = "dummy", typ = "char")
   of bcCppInherit: discard
   of bcNoneRtti:
     obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimType")))
@@ -340,10 +307,10 @@ proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType:
     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
+  if info.baseKind == bcNone and info.preFieldsLen == obj.len and
       t.itemId notin m.g.graph.memberProcsPerType:
     # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = CChar)
+    obj.addField(name = "dummy", typ = "char")
   if info.named:
     obj.add("};\n")
   else:
@@ -373,296 +340,10 @@ template addFieldWithStructType(obj: var Builder; m: BModule; parentTyp: PType;
   obj.add(fieldName)
   obj.add(";\n")
   if tfPacked in parentTyp.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    obj.add("#pragma pack(pop)\n")
+    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")
-
-template addUnionType(obj: var Builder; body: typed) =
-  ## adds a union type i.e. `union { ... }` with fields according to `body`
-  obj.add "union{\n"
-  body
-  obj.add("}")
-
-type DeclVisibility = enum
-  None
-  Extern
-  ExternC
-  ImportLib
-  ExportLib
-  ExportLibVar
-  Private
-  StaticProc
-
-proc addVisibilityPrefix(builder: var Builder, visibility: DeclVisibility) =
-  # internal proc
-  case visibility
-  of None: discard
-  of Extern:
-    builder.add("extern ")
-  of ExternC:
-    builder.add("NIM_EXTERNC ")
-  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 ")
-
-template addDeclWithVisibility(builder: var Builder, visibility: DeclVisibility, declBody: typed) =
-  ## adds a declaration as in `declBody` with the given visibility
-  builder.addVisibilityPrefix(visibility)
-  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 addProcTypedParam(builder: var Builder, paramBuilder: var ProcParamBuilder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  if paramBuilder.needsComma:
-    builder.add(", ")
-  else:
-    paramBuilder.needsComma = true
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-
-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)
-
-type SimpleProcParam = tuple
-  name, typ: string
-
-proc cProcParams(params: varargs[SimpleProcParam]): Snippet =
-  if params.len == 0: return "(void)"
-  result = "("
-  for i in 0 ..< params.len:
-    if i != 0: result.add(", ")
-    result.add(params[i].typ)
-    if params[i].name.len != 0:
-      result.add(" ")
-      result.add(params[i].name)
-  result.add(")")
-
-template addProcHeaderWithParams(builder: var Builder, callConv: TCallingConvention,
-                                 name: string, rettype: Snippet, paramBuilder: typed) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  # or enforce this with secondary builder object
-  builder.add(CallingConvToStr[callConv])
-  builder.add("(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  paramBuilder
-
-proc addProcHeader(builder: var Builder, callConv: TCallingConvention,
-                   name: string, rettype, params: Snippet) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  # or enforce this with secondary builder object
-  addProcHeaderWithParams(builder, callConv, name, rettype):
-    builder.add(params)
-
-proc addProcHeader(builder: var Builder, name: string, rettype, params: Snippet, isConstructor = false) =
-  # no callconv
-  builder.add(rettype)
-  builder.add(" ")
-  if isConstructor:
-    builder.add("__attribute__((constructor)) ")
-  builder.add(name)
-  builder.add(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
-  # or enforce this with secondary builder object
-  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.addLineEnd(";")
-
-template finishProcHeaderWithBody(builder: var Builder, body: typed) =
-  builder.addLineEndIndent(" {")
-  body
-  builder.addLineEndDedent("}")
-  builder.addNewline
-
-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.addLineEnd(";")
-
-proc addProcVar(builder: var Builder, callConv: TCallingConvention,
-                name: string, params, rettype: Snippet,
-                isStatic = false, isVolatile = false) =
-  # on nifc, builds full variable
-  if isStatic:
-    builder.add("static ")
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  if isVolatile:
-    builder.add("volatile ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  # ensure we are just adding a variable:
-  builder.addLineEnd(";")
-
-proc addProcVar(builder: var Builder,
-                name: string, params, rettype: Snippet,
-                isStatic = false, isVolatile = false) =
-  # no callconv
-  if isStatic:
-    builder.add("static ")
-  builder.add(rettype)
-  builder.add(" (*")
-  if isVolatile:
-    builder.add("volatile ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  # ensure we are just adding a variable:
-  builder.addLineEnd(";")
-
-type VarInitializerKind = enum
-  Assignment, CppConstructor
-
-proc addVar(builder: var Builder, m: BModule, s: PSym, name: string, typ: Snippet, kind = Local, visibility: DeclVisibility = None, initializer: Snippet = "", initializerKind: VarInitializerKind = Assignment) =
-  if sfCodegenDecl in s.flags:
-    builder.add(runtimeFormat(s.cgDeclFrmt, [typ, name]))
-    if initializer.len != 0:
-      if initializerKind == Assignment:
-        builder.add(" = ")
-      builder.add(initializer)
-    builder.addLineEnd(";")
-    return
-  if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
-    builder.add("NIM_ALIGN(" & $s.alignment & ") ")
-  builder.addVisibilityPrefix(visibility)
-  if kind == Threadvar:
-    if optThreads in m.config.globalOptions:
-      let sym = s.typ.sym
-      if sym != nil and sfCppNonPod in sym.flags:
-        builder.add("NIM_THREAD_LOCAL ")
-      else: builder.add("NIM_THREADVAR ")
-  else:
-    builder.addVarHeader(kind)
-  builder.add(typ)
-  if sfRegister in s.flags: builder.add(" register")
-  if sfVolatile in s.flags: builder.add(" volatile")
-  if sfNoalias in s.flags: builder.add(" NIM_NOALIAS")
-  builder.add(" ")
-  builder.add(name)
-  if initializer.len != 0:
-    if initializerKind == Assignment:
-      builder.add(" = ")
-    builder.add(initializer)
-  builder.addLineEnd(";")
-
-proc addInclude(builder: var Builder, value: Snippet) =
-  builder.addLineEnd("#include " & value)

compiler/cbuilderexprs.nim

@@ -1,19 +1,9 @@
-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 & "*"
+# XXX make complex ones like bitOr use builder instead
+# XXX add stuff like NI, NIM_NIL as constants
 
 proc ptrType(t: Snippet): Snippet =
   t & "*"
 
-proc cppRefType(t: Snippet): Snippet =
-  t & "&"
-
 const
   CallingConvToStr: array[TCallingConvention, string] = ["N_NIMCALL",
     "N_STDCALL", "N_CDECL", "N_SAFECALL",
@@ -23,237 +13,14 @@ const
     "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 procPtrTypeUnnamed(callConv: TCallingConvention, rettype, params: Snippet): Snippet =
-  CallingConvToStr[callConv] & "_PTR(" & rettype & ", )" & params
-
-type CppCaptureKind = enum None, ByReference, ByCopy
-
-template addCppLambda(builder: var Builder, captures: CppCaptureKind, params: Snippet, body: typed) =
-  builder.add("[")
-  case captures
-  of None: discard
-  of ByReference: builder.add("&")
-  of ByCopy: builder.add("=")
-  builder.add("] ")
-  builder.add(params)
-  builder.addLineEndIndent(" {")
-  body
-  builder.addLineEndDedent("}")
+proc procPtrType(conv: TCallingConvention, rettype: Snippet, name: string): Snippet =
+  CallingConvToStr[conv] & "_PTR(" & rettype & ", " & name & ")"
 
 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 & ")"
+  "&" & value
 
-proc cLabelAddr(value: TLabel): 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
-
-type CallBuilder = object
-  needsComma: bool
-
-proc initCallBuilder(builder: var Builder, callee: Snippet): CallBuilder =
-  result = CallBuilder(needsComma: false)
-  builder.add(callee)
-  builder.add("(")
-
-const cArgumentSeparator = ", "
-
-proc addArgumentSeparator(builder: var Builder) =
-  # no-op on NIFC
-  # used by "single argument" builders
-  builder.add(cArgumentSeparator)
-
-template addArgument(builder: var Builder, call: var CallBuilder, valueBody: typed) =
-  if call.needsComma:
-    builder.addArgumentSeparator()
-  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 & ")"
-
-template cUnlikely(val: Snippet): Snippet =
-  "NIM_UNLIKELY(" & val & ")"
+proc bitOr(a, b: Snippet): Snippet =
+  "(" & a & " | " & b & ")"

compiler/cbuilderstmts.nim

@@ -1,329 +0,0 @@
-template addAssignmentWithValue(builder: var Builder, lhs: Snippet, valueBody: typed) =
-  builder.add(lhs)
-  builder.add(" = ")
-  valueBody
-  builder.addLineEnd(";")
-
-template addFieldAssignmentWithValue(builder: var Builder, lhs: Snippet, name: string, valueBody: typed) =
-  builder.add(lhs)
-  builder.add("." & name & " = ")
-  valueBody
-  builder.addLineEnd(";")
-
-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.addLineEnd(";")
-
-template addSubscriptAssignment(builder: var Builder, lhs: Snippet, index: Snippet, rhs: Snippet) =
-  builder.add(lhs)
-  builder.add("[" & index & "] = ")
-  builder.add(rhs)
-  builder.addLineEnd(";")
-
-template addStmt(builder: var Builder, stmtBody: typed) =
-  ## makes an expression built by `stmtBody` into a statement
-  stmtBody
-  builder.addLineEnd(";")
-
-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.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-template addSingleIfStmtWithCond(builder: var Builder, condBody: typed, body: typed) =
-  builder.add("if (")
-  condBody
-  builder.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-proc initIfStmt(builder: var Builder): IfBuilder =
-  IfBuilder(state: WaitingIf)
-
-proc finishIfStmt(builder: var Builder, stmt: IfBuilder) =
-  assert stmt.state != InBlock
-  builder.addNewline()
-
-template addIfStmt(builder: var Builder, stmt: out IfBuilder, body: typed) =
-  stmt = initIfStmt(builder)
-  body
-  finishIfStmt(builder, stmt)
-
-proc initElifBranch(builder: var Builder, stmt: var IfBuilder, cond: Snippet) =
-  case stmt.state
-  of WaitingIf:
-    builder.add("if (")
-  of WaitingElseIf:
-    builder.add(" else if (")
-  else: assert false, $stmt.state
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  stmt.state = InBlock
-
-proc initElseBranch(builder: var Builder, stmt: var IfBuilder) =
-  assert stmt.state == WaitingElseIf, $stmt.state
-  builder.addLineEndIndent(" else {")
-  stmt.state = InBlock
-
-proc finishBranch(builder: var Builder, stmt: var IfBuilder) =
-  builder.addDedent("}")
-  stmt.state = WaitingElseIf
-
-template addElifBranch(builder: var Builder, stmt: var IfBuilder, cond: Snippet, body: typed) =
-  initElifBranch(builder, stmt, cond)
-  body
-  finishBranch(builder, stmt)
-
-template addElseBranch(builder: var Builder, stmt: var IfBuilder, body: typed) =
-  initElseBranch(builder, stmt)
-  body
-  finishBranch(builder, stmt)
-
-proc initForRange(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.addLineEndIndent("++) {")
-
-proc initForStep(builder: var Builder, i, start, bound, step: 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(" += ")
-  builder.add(step)
-  builder.addLineEndIndent(") {")
-
-proc finishFor(builder: var Builder) {.inline.} =
-  builder.addLineEndDedent("}")
-
-template addForRangeExclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  initForRange(builder, i, start, bound, false)
-  body
-  finishFor(builder)
-
-template addForRangeInclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  initForRange(builder, i, start, bound, true)
-  body
-  finishFor(builder)
-
-template addSwitchStmt(builder: var Builder, val: Snippet, body: typed) =
-  builder.add("switch (")
-  builder.add(val)
-  builder.addLineEnd(") {") # no indent
-  body
-  builder.addLineEnd("}")
-
-template addSingleSwitchCase(builder: var Builder, val: Snippet, body: typed) =
-  builder.add("case ")
-  builder.add(val)
-  builder.addLineEndIndent(":")
-  body
-  builder.addLineEndDedent("")
-
-type
-  SwitchCaseState = enum
-    None, Of, Else, Finished
-  SwitchCaseBuilder = object
-    state: SwitchCaseState
-
-proc addCase(builder: var Builder, info: var SwitchCaseBuilder, val: Snippet) =
-  if info.state != Of:
-    assert info.state == None
-    info.state = Of
-  builder.add("case ")
-  builder.add(val)
-  builder.addLineEndIndent(":")
-
-proc addCaseRange(builder: var Builder, info: var SwitchCaseBuilder, first, last: Snippet) =
-  if info.state != Of:
-    assert info.state == None
-    info.state = Of
-  builder.add("case ")
-  builder.add(first)
-  builder.add(" ... ")
-  builder.add(last)
-  builder.addLineEndIndent(":")
-
-proc addCaseElse(builder: var Builder, info: var SwitchCaseBuilder) =
-  assert info.state == None
-  info.state = Else
-  builder.addLineEndIndent("default:")
-
-template addSwitchCase(builder: var Builder, info: out SwitchCaseBuilder, caseBody, body: typed) =
-  info = SwitchCaseBuilder(state: None)
-  caseBody
-  info.state = Finished
-  body
-  builder.addLineEndDedent("")
-
-template addSwitchElse(builder: var Builder, body: typed) =
-  builder.addLineEndIndent("default:")
-  body
-  builder.addLineEndDedent("")
-
-proc addBreak(builder: var Builder) =
-  builder.addLineEnd("break;")
-
-type ScopeBuilder = object
-  inside: bool
-
-proc initScope(builder: var Builder): ScopeBuilder =
-  builder.addLineEndIndent("{")
-  result = ScopeBuilder(inside: true)
-
-proc finishScope(builder: var Builder, scope: var ScopeBuilder) =
-  assert scope.inside, "scope not inited"
-  builder.addLineEndDedent("}")
-  scope.inside = false
-
-template addScope(builder: var Builder, body: typed) =
-  builder.addLineEndIndent("{")
-  body
-  builder.addLineEndDedent("}")
-
-type WhileBuilder = object
-  inside: bool
-
-proc initWhileStmt(builder: var Builder, cond: Snippet): WhileBuilder =
-  builder.add("while (")
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  result = WhileBuilder(inside: true)
-
-proc finishWhileStmt(builder: var Builder, stmt: var WhileBuilder) =
-  assert stmt.inside, "while stmt not inited"
-  builder.addLineEndDedent("}")
-  stmt.inside = false
-
-template addWhileStmt(builder: var Builder, cond: Snippet, body: typed) =
-  builder.add("while (")
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-proc addLabel(builder: var Builder, name: TLabel) =
-  builder.add(name)
-  builder.addLineEnd(": ;")
-
-proc addReturn(builder: var Builder) =
-  builder.addLineEnd("return;")
-
-proc addReturn(builder: var Builder, value: Snippet) =
-  builder.add("return ")
-  builder.add(value)
-  builder.addLineEnd(";")
-
-proc addGoto(builder: var Builder, label: TLabel) =
-  builder.add("goto ")
-  builder.add(label)
-  builder.addLineEnd(";")
-
-proc addComputedGoto(builder: var Builder, value: Snippet) =
-  builder.add("goto *")
-  builder.add(value)
-  builder.addLineEnd(";")
-
-proc addIncr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.addLineEnd("++;")
-
-proc addDecr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.addLineEnd("--;")
-
-proc addInPlaceOp(builder: var Builder, binOp: TypedBinaryOp, t: Snippet, a, b: Snippet) =
-  builder.add(a)
-  builder.add(' ')
-  builder.add(typedBinaryOperators[binOp])
-  builder.add("= ")
-  builder.add(b)
-  builder.addLineEnd(";")
-
-proc addInPlaceOp(builder: var Builder, binOp: UntypedBinaryOp, a, b: Snippet) =
-  builder.add(a)
-  builder.add(' ')
-  builder.add(untypedBinaryOperators[binOp])
-  builder.add("= ")
-  builder.add(b)
-  builder.addLineEnd(";")
-
-proc cInPlaceOp(binOp: TypedBinaryOp, t: Snippet, a, b: Snippet): Snippet =
-  result = ""
-  result.add(a)
-  result.add(' ')
-  result.add(typedBinaryOperators[binOp])
-  result.add("= ")
-  result.add(b)
-  result.add(";\n")
-
-proc cInPlaceOp(binOp: UntypedBinaryOp, a, b: Snippet): Snippet =
-  result = ""
-  result.add(a)
-  result.add(' ')
-  result.add(untypedBinaryOperators[binOp])
-  result.add("= ")
-  result.add(b)
-  result.add(";\n")
-
-template addCPragma(builder: var Builder, val: Snippet) =
-  builder.addNewline()
-  builder.add("#pragma ")
-  builder.add(val)
-  builder.addNewline()
-
-proc addDiscard(builder: var Builder, val: Snippet) =
-  builder.add("(void)")
-  builder.add(val)
-  builder.addLineEnd(";")

compiler/ccgcalls.nim

@@ -84,21 +84,20 @@ proc cleanupTemp(p: BProc; returnType: PType, tmp: TLoc): bool =
     let dtor = getAttachedOp(p.module.g.graph, returnType, attachedDestructor)
     var op = initLocExpr(p, newSymNode(dtor))
     var callee = rdLoc(op)
-    let destroyArg =
-      if dtor.typ.firstParamType.kind == tyVar:
-        cAddr(rdLoc(tmp))
+    let destroy = if dtor.typ.firstParamType.kind == tyVar:
+        callee & "(&" & rdLoc(tmp) & ")"
       else:
-        rdLoc(tmp)
-    let destroy = cCall(callee, destroyArg)
+        callee & "(" & rdLoc(tmp) & ")"
     raiseExitCleanup(p, destroy)
     result = true
   else:
     result = false
 
 proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
-               result: var Builder, call: var CallBuilder) =
+               callee, params: Rope) =
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   genLineDir(p, ri)
+  var pl = callee & "(" & params
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   if typ.returnType != nil:
@@ -107,6 +106,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       # perhaps generate no temp if the call doesn't have side effects
       flags.incl needTempForOpenArray
     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':
@@ -114,39 +114,33 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        let rad = addrLoc(p.config, d)
-        result.addArgument(call):
-          result.add(rad)
-        result.finishCallBuilder(call)
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(result))
+        pl.add(addrLoc(p.config, d))
+        pl.add(");\n")
+        line(p, cpsStmts, pl)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        let ratmp = addrLoc(p.config, tmp)
-        result.addArgument(call):
-          result.add(ratmp)
-        result.finishCallBuilder(call)
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(result))
+        pl.add(addrLoc(p.config, tmp))
+        pl.add(");\n")
+        line(p, cpsStmts, pl)
         genAssignment(p, d, tmp, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
-      result.finishCallBuilder(call)
+      pl.add(")")
       if p.module.compileToCpp:
         if 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 = extract(result)
+          d.snippet = pl
           excl d.flags, lfSingleUse
         else:
-          if d.k == locNone and p.splitDecls == 0 and p.config.exc != excGoto:
-            d = getTempCpp(p, typ.returnType, extract(result))
+          if d.k == locNone and p.splitDecls == 0:
+            d = getTempCpp(p, typ.returnType, pl)
           else:
             if d.k == locNone: d = getTemp(p, typ.returnType)
             var list = initLoc(locCall, d.lode, OnUnknown)
-            list.snippet = extract(result)
+            list.snippet = pl
             genAssignment(p, d, list, {needAssignCall}) # no need for deep copying
             if canRaise: raiseExit(p)
 
@@ -157,7 +151,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(result)
+        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)):
@@ -165,16 +159,15 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(result)
+        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)
         genAssignment(p, d, tmp, {})
   else:
-    finishCallBuilder(result, call)
-    p.s(cpsStmts).addStmt():
-      p.s(cpsStmts).add(extract(result))
+    pl.add(");\n")
+    line(p, cpsStmts, pl)
     if canRaise: raiseExit(p)
 
 proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType)
@@ -206,49 +199,49 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   if optBoundsCheck in p.options:
     genBoundsCheck(p, a, b, c, ty)
   if prepareForMutation:
-    let bra = byRefLoc(p, a)
-    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-      bra)
+    linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
   let dest = getTypeDesc(p.module, destType)
-  let ra = rdLoc(a)
-  let rb = rdLoc(b)
-  let rc = rdLoc(c)
-  let lengthExpr = cOp(Add, NimInt, cOp(Sub, NimInt, rc, rb), cIntValue(1))
+  let lengthExpr = "($1)-($2)+1" % [rdLoc(c), rdLoc(b)]
   case ty.kind
   of tyArray:
     let first = toInt64(firstOrd(p.config, ty))
     if first == 0:
-      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
+      result = ("($3*)(($1)+($2))" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
     else:
-      let lit = cIntLiteral(first)
-      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, cOp(Sub, NimInt, rb, lit))), lengthExpr)
+      var lit = newRopeAppender()
+      intLiteral(first, lit)
+      result = ("($4*)($1)+(($2)-($3))" %
+        [rdLoc(a), rdLoc(b), lit, dest],
+        lengthExpr)
   of tyOpenArray, tyVarargs:
-    let data = if reifiedOpenArray(q[1]): dotField(ra, "Field0") else: ra
-    result = (cCast(ptrType(dest), cOp(Add, NimInt, data, rb)), lengthExpr)
+    if reifiedOpenArray(q[1]):
+      result = ("($3*)($1.Field0)+($2)" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
+    else:
+      result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
   of tyUncheckedArray, tyCstring:
-    result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
+    result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
+              lengthExpr)
   of tyString, tySequence:
     let atyp = skipTypes(a.t, abstractInst)
     if formalType.skipTypes(abstractInst).kind in {tyVar} and atyp.kind == tyString and
         optSeqDestructors in p.config.globalOptions:
-      let bra = byRefLoc(p, a)
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-        bra)
-    var val: Snippet
+      linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
     if atyp.kind in {tyVar} and not compileToCpp(p.module):
-      val = cDeref(ra)
+      result = ("(($5) ? (($4*)(*$1)$3+($2)) : NIM_NIL)" %
+                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, "*" & rdLoc(a))],
+                lengthExpr)
     else:
-      val = ra
-    result = (
-      cIfExpr(dataFieldAccessor(p, val),
-        cCast(ptrType(dest), cOp(Add, NimInt, dataField(p, val), rb)),
-        NimNil),
-      lengthExpr)
+      result = ("(($5) ? (($4*)$1$3+($2)) : NIM_NIL)" %
+                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, rdLoc(a))],
+                lengthExpr)
   else:
     result = ("", "")
     internalError(p.config, "openArrayLoc: " & typeToString(a.t))
 
-proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
+proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
   var q = skipConv(n)
   var skipped = false
   while q.kind == nkStmtListExpr and q.len > 0:
@@ -263,66 +256,42 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
           genStmts(p, q[i])
         q = q.lastSon
     let (x, y) = genOpenArraySlice(p, q, formalType, n.typ.elementType)
-    result.add(x)
-    result.addArgumentSeparator()
-    result.add(y)
+    result.add x & ", " & y
   else:
     var a = initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n)
     case skipTypes(a.t, abstractVar+{tyStatic}).kind
     of tyOpenArray, tyVarargs:
-      let ra = rdLoc(a)
       if reifiedOpenArray(n):
         if a.t.kind in {tyVar, tyLent}:
-          result.add(derefField(ra, "Field0"))
-          result.addArgumentSeparator()
-          result.add(derefField(ra, "Field1"))
+          result.add "$1->Field0, $1->Field1" % [rdLoc(a)]
         else:
-          result.add(dotField(ra, "Field0"))
-          result.addArgumentSeparator()
-          result.add(dotField(ra, "Field1"))
+          result.add "$1.Field0, $1.Field1" % [rdLoc(a)]
       else:
-        result.add(ra)
-        result.addArgumentSeparator()
-        result.add(ra & "Len_0")
+        result.add "$1, $1Len_0" % [rdLoc(a)]
     of tyString, tySequence:
       let ntyp = skipTypes(n.typ, abstractInst)
       if formalType.skipTypes(abstractInst).kind in {tyVar} and ntyp.kind == tyString and
           optSeqDestructors in p.config.globalOptions:
-        let bra = byRefLoc(p, a)
-        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-          bra)
+        linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
       if ntyp.kind in {tyVar} and not compileToCpp(p.module):
-        let ra = a.rdLoc
-        var t = TLoc(snippet: cDeref(ra))
-        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
-        result.addArgumentSeparator()
-        result.add(lt)
+        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                      dataFieldAccessor(p, "*" & a.rdLoc)]
       else:
-        let ra = a.rdLoc
-        let la = lenExpr(p, a)
-        result.add(cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
-        result.addArgumentSeparator()
-        result.add(la)
+        result.add "($4) ? ($1$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, a), dataField(p), dataFieldAccessor(p, a.rdLoc)]
     of tyArray:
-      let ra = rdLoc(a)
-      result.add(ra)
-      result.addArgumentSeparator()
-      result.addIntValue(lengthOrd(p.config, a.t))
+      result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, a.t))]
     of tyPtr, tyRef:
       case elementType(a.t).kind
       of tyString, tySequence:
-        let ra = a.rdLoc
-        var t = TLoc(snippet: cDeref(ra))
-        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
-        result.addArgumentSeparator()
-        result.add(lt)
+        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                      dataFieldAccessor(p, "*" & a.rdLoc)]
       of tyArray:
-        let ra = rdLoc(a)
-        result.add(ra)
-        result.addArgumentSeparator()
-        result.addIntValue(lengthOrd(p.config, elementType(a.t)))
+        result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, elementType(a.t)))]
       else:
         internalError(p.config, "openArrayLoc: " & typeToString(a.t))
     else: internalError(p.config, "openArrayLoc: " & typeToString(a.t))
@@ -338,16 +307,15 @@ proc withTmpIfNeeded(p: BProc, a: TLoc, needsTmp: bool): TLoc =
   else:
     result = a
 
-proc expressionsNeedsTmp(p: BProc, a: TLoc): TLoc =
+proc literalsNeedsTmp(p: BProc, a: TLoc): TLoc =
   result = getTemp(p, a.lode.typ, needsInit=false)
   genAssignment(p, result, a, {})
 
-proc genArgStringToCString(p: BProc, n: PNode; result: var Builder; needsTmp: bool) {.inline.} =
+proc genArgStringToCString(p: BProc, n: PNode; result: var Rope; needsTmp: bool) {.inline.} =
   var a = initLocExpr(p, n[0])
-  let ra = withTmpIfNeeded(p, a, needsTmp).rdLoc
-  result.addCall(cgsymValue(p.module, "nimToCStringConv"), ra)
+  appcg(p.module, result, "#nimToCStringConv($1)", [withTmpIfNeeded(p, a, needsTmp).rdLoc])
 
-proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; needsTmp = false) =
+proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -358,7 +326,7 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; n
     (optByRef notin param.options or not p.module.compileToCpp):
     a = initLocExpr(p, n)
     if n.kind in {nkCharLit..nkNilLit}:
-      addAddrLoc(p.config, expressionsNeedsTmp(p, a), result)
+      addAddrLoc(p.config, literalsNeedsTmp(p, a), result)
     else:
       addAddrLoc(p.config, withTmpIfNeeded(p, a, needsTmp), result)
   elif p.module.compileToCpp and param.typ.kind in {tyVar} and
@@ -368,8 +336,8 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; n
     # 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.incl tfVarIsPtr
+      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
@@ -388,11 +356,12 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; 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 = cCast(getTypeDesc(p.module, param.typ), rdCharLoc(a))
+        a.snippet = "(($1) ($2))" %
+          [getTypeDesc(p.module, param.typ), rdCharLoc(a)]
     addRdLoc(withTmpIfNeeded(p, a, needsTmp), result)
   #assert result != nil
 
-proc genArgNoParam(p: BProc, n: PNode; result: var Builder; needsTmp = false) =
+proc genArgNoParam(p: BProc, n: PNode; result: var Rope; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -418,6 +387,35 @@ proc skipTrivialIndirections(n: PNode): PNode =
       result = result[1]
     else: break
 
+proc getPotentialWrites(n: PNode; mutate: bool; result: var seq[PNode]) =
+  case n.kind:
+  of nkLiterals, nkIdent, nkFormalParams: discard
+  of nkSym:
+    if mutate: result.add n
+  of nkAsgn, nkFastAsgn, nkSinkAsgn:
+    getPotentialWrites(n[0], true, result)
+    getPotentialWrites(n[1], mutate, result)
+  of nkAddr, nkHiddenAddr:
+    getPotentialWrites(n[0], true, result)
+  of nkBracketExpr, nkDotExpr, nkCheckedFieldExpr:
+    getPotentialWrites(n[0], mutate, result)
+  of nkCallKinds:
+    case n.getMagic:
+    of mIncl, mExcl, mInc, mDec, mAppendStrCh, mAppendStrStr, mAppendSeqElem,
+        mAddr, mNew, mNewFinalize, mWasMoved, mDestroy:
+      getPotentialWrites(n[1], true, result)
+      for i in 2..<n.len:
+        getPotentialWrites(n[i], mutate, result)
+    of mSwap:
+      for i in 1..<n.len:
+        getPotentialWrites(n[i], true, result)
+    else:
+      for i in 1..<n.len:
+        getPotentialWrites(n[i], mutate, result)
+  else:
+    for s in n:
+      getPotentialWrites(s, mutate, result)
+
 proc getPotentialReads(n: PNode; result: var seq[PNode]) =
   case n.kind:
   of nkLiterals, nkIdent, nkFormalParams: discard
@@ -426,7 +424,7 @@ proc getPotentialReads(n: PNode; result: var seq[PNode]) =
     for s in n:
       getPotentialReads(s, result)
 
-proc genParams(p: BProc, ri: PNode, typ: PType; result: var Builder, argBuilder: var CallBuilder) =
+proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
   # We must generate temporaries in cases like #14396
   # to keep the strict Left-To-Right evaluation
   var needTmp = newSeq[bool](ri.len - 1)
@@ -448,22 +446,21 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Builder, argBuilder:
         # 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:
       assert(typ.n[i].kind == nkSym)
       let paramType = typ.n[i]
       if not paramType.typ.isCompileTimeOnly:
-        var arg = newBuilder("")
-        genArg(p, ri[i], paramType.sym, ri, arg, needTmp[i-1])
-        if arg.buf.len != 0:
-          result.addArgument(argBuilder):
-            result.add(extract(arg))
+        if oldLen != result.len:
+          result.add(", ")
+          oldLen = result.len
+        genArg(p, ri[i], paramType.sym, ri, result, needTmp[i-1])
     else:
-      var arg = newBuilder("")
-      genArgNoParam(p, ri[i], arg, needTmp[i-1])
-      if arg.buf.len != 0:
-        result.addArgument(argBuilder):
-          result.add(extract(arg))
+      if oldLen != result.len:
+        result.add(", ")
+        oldLen = result.len
+      genArgNoParam(p, ri[i], result, needTmp[i-1])
 
 proc addActualSuffixForHCR(res: var Rope, module: PSym, sym: PSym) =
   if sym.flags * {sfImportc, sfNonReloadable} == {} and sym.loc.k == locProc and
@@ -477,39 +474,21 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
+  var params = newRopeAppender()
+  genParams(p, ri, typ, params)
+
   var callee = rdLoc(op)
   if p.hcrOn and ri[0].kind == nkSym:
     callee.addActualSuffixForHCR(p.module.module, ri[0].sym)
-
-  var res = newBuilder("")
-  var call = initCallBuilder(res, callee)
-  genParams(p, ri, typ, res, call)
-  fixupCall(p, le, ri, d, res, call)
+  fixupCall(p, le, ri, d, callee, params)
 
 proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
-  template callProc(rp, params, pTyp: Snippet): Snippet =
-    let e = dotField(rp, "ClE_0")
-    let p = dotField(rp, "ClP_0")
-    let eCall =
-      # note `params` here is actually multiple params
-      if params.len == 0:
-        cCall(p, e)
-      else:
-        cCall(p, params, e)
-    cIfExpr(e,
-      eCall,
-      cCall(cCast(pTyp, p), params))
+  proc addComma(r: Rope): Rope =
+    if r.len == 0: r else: r & ", "
 
-  template callIter(rp, params: Snippet): Snippet =
-    # we know the env exists
-    let e = dotField(rp, "ClE_0")
-    let p = dotField(rp, "ClP_0")
-    # note `params` here is actually multiple params
-    if params.len == 0:
-      cCall(p, e)
-    else:
-      cCall(p, params, e)
+  const PatProc = "$1.ClE_0? $1.ClP_0($3$1.ClE_0):(($4)($1.ClP_0))($2)"
+  const PatIter = "$1.ClP_0($3$1.ClE_0)" # we know the env exists
 
   var op = initLocExpr(p, ri[0])
 
@@ -517,23 +496,20 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
-  var params = newBuilder("")
-  var argBuilder = default(CallBuilder) # not initCallBuilder, we just want the params
-  genParams(p, ri, typ, params, argBuilder)
+  var pl = newRopeAppender()
+  genParams(p, ri, typ, pl)
 
   template genCallPattern {.dirty.} =
-    let rp = rdLoc(op)
-    let pars = extract(params)
-    p.s(cpsStmts).addStmt():
-      if tfIterator in typ.flags:
-        p.s(cpsStmts).add(callIter(rp, pars))
-      else:
-        p.s(cpsStmts).add(callProc(rp, pars, rawProc))
+    if tfIterator in typ.flags:
+      lineF(p, cpsStmts, PatIter & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
+    else:
+      lineF(p, cpsStmts, PatProc & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
 
   let rawProc = getClosureType(p.module, typ, clHalf)
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   if typ.returnType != 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':
@@ -542,14 +518,12 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        params.addArgument(argBuilder):
-          params.add(addrLoc(p.config, d))
+        pl.add(addrLoc(p.config, d))
         genCallPattern()
         if canRaise: raiseExit(p)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        params.addArgument(argBuilder):
-          params.add(addrLoc(p.config, tmp))
+        pl.add(addrLoc(p.config, tmp))
         genCallPattern()
         if canRaise: raiseExit(p)
         genAssignment(p, d, tmp, {}) # no need for deep copying
@@ -557,24 +531,20 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
       if d.k == locNone: d = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-      let rp = rdLoc(op)
-      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = callIter(rp, pars)
+        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = callProc(rp, pars, rawProc)
+        list.snippet = 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)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-      let rp = rdLoc(op)
-      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = callIter(rp, pars)
+        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = callProc(rp, pars, rawProc)
+        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
       genAssignment(p, tmp, list, {})
       if canRaise: raiseExit(p)
       genAssignment(p, d, tmp, {})
@@ -582,8 +552,8 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
     genCallPattern()
     if canRaise: raiseExit(p)
 
-proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder;
-                 argBuilder: var CallBuilder) =
+proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope;
+                 argsCounter: var int) =
   if i < typ.n.len:
     # 'var T' is 'T&' in C++. This means we ignore the request of
     # any nkHiddenAddr when it's a 'var T'.
@@ -592,17 +562,20 @@ proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder;
     if paramType.typ.isCompileTimeOnly:
       discard
     elif paramType.typ.kind in {tyVar} and ri[i].kind == nkHiddenAddr:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i][0], result)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i][0], result)
+      inc argsCounter
     else:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
+      inc argsCounter
   else:
     if tfVarargs notin typ.flags:
       localError(p.config, ri.info, "wrong argument count")
     else:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i], result)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i], result)
+      inc argsCounter
 
 discard """
 Dot call syntax in C++
@@ -659,7 +632,7 @@ proc skipAddrDeref(node: PNode): PNode =
   else:
     result = node
 
-proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder) =
+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.
@@ -694,15 +667,15 @@ proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder) =
     genArgNoParam(p, ri, result) #, typ.n[i].sym)
     result.add(".")
 
-proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Builder) =
+proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Rope) =
   var i = 0
   var j = 1
   while i < pat.len:
     case pat[i]
     of '@':
-      var callBuilder = default(CallBuilder) # not init call builder
+      var argsCounter = 0
       for k in j..<ri.len:
-        genOtherArg(p, ri, k, typ, result, callBuilder)
+        genOtherArg(p, ri, k, typ, result, argsCounter)
       inc i
     of '#':
       if i+1 < pat.len and pat[i+1] in {'+', '@'}:
@@ -712,11 +685,11 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Bu
           if pat[i+1] == '+': genArgNoParam(p, ri[0], result)
           result.add("(")
           if 1 < ri.len:
-            var callBuilder: CallBuilder = default(CallBuilder)
-            genOtherArg(p, ri, 1, typ, result, callBuilder)
+            var argsCounterB = 0
+            genOtherArg(p, ri, 1, typ, result, argsCounterB)
           for k in j+1..<ri.len:
-            var callBuilder: CallBuilder = default(CallBuilder)
-            genOtherArg(p, ri, k, typ, result, callBuilder)
+            var argsCounterB = 0
+            genOtherArg(p, ri, k, typ, result, argsCounterB)
           result.add(")")
         else:
           localError(p.config, ri.info, "call expression expected for C++ pattern")
@@ -730,15 +703,15 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Bu
         genArgNoParam(p, arg, result)
         #result.add debugTree(arg, 0, 10)
       else:
-        var callBuilder = default(CallBuilder) # not init call builder
-        genOtherArg(p, ri, j, typ, result, callBuilder)
+        var argsCounter = 0
+        genOtherArg(p, ri, j, typ, result, argsCounter)
       inc j
       inc i
     of '\'':
       var idx, stars: int = 0
       if scanCppGenericSlot(pat, i, idx, stars):
         var t = resolveStarsInCppType(typ, idx, stars)
-        if t == nil: result.add(CVoid)
+        if t == nil: result.add("void")
         else: result.add(getTypeDesc(p.module, t))
     else:
       let start = i
@@ -757,7 +730,7 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   let pat = $ri[0].sym.loc.snippet
   internalAssert p.config, pat.len > 0
   if pat.contains({'#', '(', '@', '\''}):
-    var pl = newBuilder("")
+    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)
@@ -767,32 +740,32 @@ proc genInfixCall(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 = extract(pl)
+        d.snippet = pl
         excl d.flags, lfSingleUse
       else:
         if d.k == locNone: d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(pl)
+        list.snippet = pl
         genAssignment(p, d, list, {}) # no need for deep copying
     else:
-      p.s(cpsStmts).addStmt():
-        p.s(cpsStmts).add(extract(pl))
+      pl.add(";\n")
+      line(p, cpsStmts, pl)
   else:
-    var pl = newBuilder("")
+    var pl = newRopeAppender()
+    var argsCounter = 0
     if 1 < ri.len:
       genThisArg(p, ri, 1, typ, pl)
     pl.add(op.snippet)
-    var res = newBuilder("")
-    var call = initCallBuilder(res, extract(pl))
+    var params = newRopeAppender()
     for i in 2..<ri.len:
-      genOtherArg(p, ri, i, typ, res, call)
-    fixupCall(p, le, ri, d, res, call)
+      genOtherArg(p, ri, i, typ, params, argsCounter)
+    fixupCall(p, le, ri, d, pl, params)
 
 proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
   # generates a crappy ObjC call
   var op = initLocExpr(p, ri[0])
-  var pl = newBuilder("[")
+  var pl = "["
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   assert(typ.kind == tyProc)
@@ -834,27 +807,24 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
         if d.k == locNone: d = getTemp(p, typ.returnType, needsInit=true)
         pl.add("Result: ")
         pl.add(addrLoc(p.config, d))
-        pl.add("]")
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(pl))
+        pl.add("];\n")
+        line(p, cpsStmts, pl)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         pl.add(addrLoc(p.config, tmp))
-        pl.add("]")
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(pl))
+        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)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, ri, OnUnknown)
-      list.snippet = extract(pl)
+      list.snippet = pl
       genAssignment(p, d, list, {}) # no need for deep copying
   else:
-    pl.add("]")
-    p.s(cpsStmts).addStmt():
-      p.s(cpsStmts).add(extract(pl))
+    pl.add("];\n")
+    line(p, cpsStmts, pl)
 
 proc notYetAlive(n: PNode): bool {.inline.} =
   let r = getRoot(n)

compiler/ccgliterals.nim

@@ -16,10 +16,13 @@
 ## implementation.
 
 template detectVersion(field, corename) =
-  if m.g.config.selectedGC in {gcArc, gcOrc, gcAtomicArc, gcHooks}:
-    result = 2
-  else:
-    result = 1
+  if m.g.field == 0:
+    let core = getCompilerProc(m.g.graph, corename)
+    if core == nil or core.kind != skConst:
+      m.g.field = 1
+    else:
+      m.g.field = toInt(ast.getInt(core.astdef))
+  result = m.g.field
 
 proc detectStrVersion(m: BModule): int =
   detectVersion(strVersion, "nimStrVersion")
@@ -37,7 +40,7 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
   res.addVarWithTypeAndInitializer(AlwaysConst, name = tmp):
     res.addSimpleStruct(m, name = "", baseType = ""):
       res.addField(name = "Sup", typ = "TGenericSeq")
-      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
+      res.addArrayField(name = "data", elementType = "NIM_CHAR", len = s.len + 1)
   do:
     var strInit: StructInitializer
     res.addStructInitializer(strInit, kind = siOrderedStruct):
@@ -45,16 +48,16 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
         var seqInit: StructInitializer
         res.addStructInitializer(seqInit, kind = siOrderedStruct):
           res.addField(seqInit, name = "len"):
-            res.addIntValue(s.len)
+            res.add(rope(s.len))
           res.addField(seqInit, name = "reserved"):
-            res.add(cCast(NimInt, cOp(BitOr, NimUint, cCast(NimUint, cIntValue(s.len)), NimStrlitFlag)))
+            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].add(res)
 
-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")), NimNil))
+    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), "NIM_NIL"))
   else:
     let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
     var name: string = ""
@@ -73,18 +76,18 @@ proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bo
       if isConst: AlwaysConst else: Global,
       name = result):
     res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "cap", typ = NimInt)
-      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
+      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(cOp(BitOr, NimInt, cIntValue(s.len), NimStrlitFlag))
+        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].add(res)
 
-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:
@@ -98,19 +101,20 @@ proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Builder
   let tmp = getTempName(m)
   result.add tmp
   var res = newBuilder("")
-  res.addVarWithInitializer(
+  res.addVarWithTypeAndInitializer(
       if isConst: AlwaysConst else: Global,
-      name = tmp,
-      typ = "NimStringV2"):
+      name = tmp):
+    res.add("NimStringV2")
+  do:
     var strInit: StructInitializer
     res.addStructInitializer(strInit, kind = siOrderedStruct):
       res.addField(strInit, name = "len"):
-        res.addIntValue(n.strVal.len)
+        res.add(rope(n.strVal.len))
       res.addField(strInit, name = "p"):
         res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].add(res)
 
-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,7 +128,7 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Bu
   var strInit: StructInitializer
   result.addStructInitializer(strInit, kind = siOrderedStruct):
     result.addField(strInit, name = "len"):
-      result.addIntValue(n.strVal.len)
+      result.add(rope(n.strVal.len))
     result.addField(strInit, name = "p"):
       result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
 
@@ -141,10 +145,10 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
   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")), NimNil))
+proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
+  result.add(cCast(ptrType(cgsymValue(m, "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)

compiler/ccgreset.nim

@@ -27,28 +27,25 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
     if disc.loc.snippet == "": fillObjectFields(p.module, typ)
     if disc.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    let discField = dotField(accessor, disc.loc.snippet)
-    p.s(cpsStmts).addSwitchStmt(discField):
-      for i in 1..<n.len:
-        let branch = n[i]
-        assert branch.kind in {nkOfBranch, nkElse}
-        var caseBuilder: SwitchCaseBuilder
-        p.s(cpsStmts).addSwitchCase(caseBuilder):
-          if branch.kind == nkOfBranch:
-            genCaseRange(p, branch, caseBuilder)
-          else:
-            p.s(cpsStmts).addCaseElse(caseBuilder)
-        do:
-          specializeResetN(p, accessor, lastSon(branch), typ)
-          p.s(cpsStmts).addBreak()
-    specializeResetT(p, discField, disc.loc.t)
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    for i in 1..<n.len:
+      let branch = n[i]
+      assert branch.kind in {nkOfBranch, nkElse}
+      if branch.kind == nkOfBranch:
+        genCaseRange(p, branch)
+      else:
+        lineF(p, cpsStmts, "default:$n", [])
+      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)
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
     if field.loc.snippet == "": fillObjectFields(p.module, typ)
     if field.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    specializeResetT(p, dotField(accessor, field.loc.snippet), field.loc.t)
+    specializeResetT(p, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
   else: internalError(p.config, n.info, "specializeResetN()")
 
 proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
@@ -61,51 +58,40 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
   of tyArray:
     let arraySize = lengthOrd(p.config, typ.indexType)
     var i: TLoc = getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt))
-    p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), cIntValue(arraySize)):
-      specializeResetT(p, subscript(accessor, i.snippet), typ.elementType)
+    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)
+    lineF(p, cpsStmts, "}$n", [])
   of tyObject:
     var x = typ.baseClass
     if x != nil: x = x.skipTypes(skipPtrs)
     specializeResetT(p, accessor.parentObj(p.module), x)
-    if typ.n != nil:
-      if typ.sym != nil and sfImportc in typ.sym.flags:
-        # imported C struct, nimZeroMem
-        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
-          cCast(ptrType(CPointer), cAddr(accessor)),
-          cSizeof(getTypeDesc(p.module, typ)))
-      else:
-        specializeResetN(p, accessor, typ.n, typ)
+    if typ.n != nil: specializeResetN(p, accessor, typ.n, typ)
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:
-      specializeResetT(p, dotField(accessor, "Field" & $i), a)
+      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), a)
 
   of tyString, tyRef, tySequence:
-    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-      cCast(ptrType(CPointer), cAddr(accessor)),
-      NimNil)
+    lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1, NIM_NIL);$n", [accessor])
 
   of tyProc:
     if typ.callConv == ccClosure:
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-        cCast(ptrType(CPointer), cAddr(dotField(accessor, "ClE_0"))),
-        NimNil)
-      p.s(cpsStmts).addFieldAssignment(accessor, "ClP_0", NimNil)
+      lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1.ClE_0, NIM_NIL);$n", [accessor])
+      lineCg(p, cpsStmts, "$1.ClP_0 = NIM_NIL;$n", [accessor])
     else:
-      p.s(cpsStmts).addAssignment(accessor, NimNil)
+      lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
   of tyChar, tyBool, tyEnum, tyRange, tyInt..tyUInt64:
-    p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
+    lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
   of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
-    p.s(cpsStmts).addAssignment(accessor, NimNil)
+    lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
   of tySet:
     case mapSetType(p.config, typ)
     of ctArray:
-      let t = getTypeDesc(p.module, typ)
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
-        accessor,
-        cSizeof(t))
+      lineCg(p, cpsStmts, "#nimZeroMem($1, sizeof($2));$n",
+          [accessor, getTypeDesc(p.module, typ)])
     of ctInt8, ctInt16, ctInt32, ctInt64:
-      p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
+      lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
     else:
       raiseAssert "unexpected set type kind"
   of tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,

compiler/ccgthreadvars.nim

@@ -19,12 +19,9 @@ proc accessThreadLocalVar(p: BProc, s: PSym) =
   if emulatedThreadVars(p.config) and threadVarAccessed notin p.flags:
     p.flags.incl threadVarAccessed
     incl p.module.flags, usesThreadVars
-    p.procSec(cpsLocals).addVar(kind = Local,
-      name = "NimTV_",
-      typ = ptrType("NimThreadVars"))
-    p.procSec(cpsInit).addAssignment("NimTV_",
-      cCast(ptrType("NimThreadVars"),
-        cCall(cgsymValue(p.module, "GetThreadLocalVars"))))
+    p.procSec(cpsLocals).addf("\tNimThreadVars* NimTV_;$n", [])
+    p.procSec(cpsInit).add(
+      ropecg(p.module, "\tNimTV_ = (NimThreadVars*) #GetThreadLocalVars();$n", []))
 
 proc declareThreadVar(m: BModule, s: PSym, isExtern: bool) =
   if emulatedThreadVars(m.config):
@@ -33,32 +30,34 @@ 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.addField(name = s.loc.snippet, typ = getTypeDesc(m, s.loc.t))
+      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.loc.t), s.loc.snippet])
   else:
-    let vis =
-      if isExtern: Extern
-      elif lfExportLib in s.loc.flags: ExportLibVar
-      else: Private
-    m.s[cfsVars].addVar(m, s,
-      name = s.loc.snippet,
-      typ = getTypeDesc(m, s.loc.t),
-      kind = Threadvar,
-      visibility = vis)
+    if isExtern: m.s[cfsVars].add("extern ")
+    elif lfExportLib in s.loc.flags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
+    else: m.s[cfsVars].add("N_LIB_PRIVATE ")
+    if optThreads in m.config.globalOptions:
+      let sym = s.typ.sym
+      if sym != nil and sfCppNonPod in sym.flags:
+        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])
 
 proc generateThreadLocalStorage(m: BModule) =
-  if m.g.nimtv.buf.len != 0 and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
+  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(extract(m.g.nimtv))
+    var typedef = newBuilder("")
+    typedef.addTypedef(name = "NimThreadVars"):
+      typedef.addSimpleStruct(m, name = "", baseType = ""):
+        typedef.add(m.g.nimtv)
+    m.s[cfsSeqTypes].add(typedef)
 
 proc generateThreadVarsSize(m: BModule) =
-  if m.g.nimtv.buf.len != 0:
+  if m.g.nimtv != "":
     let externc = if m.config.backend == backendCpp or
-                       sfCompileToCpp in m.module.flags: ExternC
-                  else: None
-    m.s[cfsProcs].addDeclWithVisibility(externc):
-      m.s[cfsProcs].addProcHeader("NimThreadVarsSize", NimInt, cProcParams())
-      m.s[cfsProcs].finishProcHeaderWithBody():
-        m.s[cfsProcs].addReturn(cCast(NimInt, cSizeof("NimThreadVars")))
+                       sfCompileToCpp in m.module.flags: "extern \"C\" "
+                  else: ""
+    m.s[cfsProcs].addf(
+      "$#NI NimThreadVarsSize(){return (NI)sizeof(NimThreadVars);}$n",
+      [externc.rope])

compiler/ccgtrav.nim

@@ -16,16 +16,13 @@ type
     p: BProc
     visitorFrmt: string
 
+const
+  visitorFrmt = "#nimGCvisit((void*)$1, $2);$n"
 
 proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType)
-proc genCaseRange(p: BProc, branch: PNode, info: var SwitchCaseBuilder)
+proc genCaseRange(p: BProc, branch: PNode)
 proc getTemp(p: BProc, t: PType, needsInit=false): TLoc
 
-proc visit(p: BProc, data, visitor: Snippet) =
-  p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisit"),
-    cCast(CPointer, data),
-    visitor)
-
 proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
                      typ: PType) =
   if n == nil: return
@@ -40,32 +37,29 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
     if disc.loc.snippet == "": fillObjectFields(c.p.module, typ)
     if disc.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    let discField = dotField(accessor, disc.loc.snippet)
-    p.s(cpsStmts).addSwitchStmt(discField):
-      for i in 1..<n.len:
-        let branch = n[i]
-        assert branch.kind in {nkOfBranch, nkElse}
-        var caseBuilder: SwitchCaseBuilder
-        p.s(cpsStmts).addSwitchCase(caseBuilder):
-          if branch.kind == nkOfBranch:
-            genCaseRange(c.p, branch, caseBuilder)
-          else:
-            p.s(cpsStmts).addCaseElse(caseBuilder)
-        do:
-          genTraverseProc(c, accessor, lastSon(branch), typ)
-          p.s(cpsStmts).addBreak()
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    for i in 1..<n.len:
+      let branch = n[i]
+      assert branch.kind in {nkOfBranch, nkElse}
+      if branch.kind == nkOfBranch:
+        genCaseRange(c.p, branch)
+      else:
+        lineF(p, cpsStmts, "default:$n", [])
+      genTraverseProc(c, accessor, lastSon(branch), typ)
+      lineF(p, cpsStmts, "break;$n", [])
+    lineF(p, cpsStmts, "} $n", [])
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
     if field.loc.snippet == "": fillObjectFields(c.p.module, typ)
     if field.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    genTraverseProc(c, dotField(accessor, field.loc.snippet), field.loc.t)
+    genTraverseProc(c, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
   else: internalError(c.p.config, n.info, "genTraverseProc()")
 
 proc parentObj(accessor: Rope; m: BModule): Rope {.inline.} =
   if not m.compileToCpp:
-    result = dotField(accessor, "Sup")
+    result = "$1.Sup" % [accessor]
   else:
     result = accessor
 
@@ -82,14 +76,16 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
     let arraySize = lengthOrd(c.p.config, typ.indexType)
     var i: TLoc = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
     var oldCode = p.s(cpsStmts)
-    var oldLen, newLen: int
-    p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), cIntValue(arraySize)):
-      oldLen = p.s(cpsStmts).buf.len
-      genTraverseProc(c, subscript(accessor, i.snippet), typ.elementType)
-      newLen = p.s(cpsStmts).buf.len
-    if oldLen == newLen:
+    freeze oldCode
+    linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
+            [i.snippet, arraySize])
+    let oldLen = p.s(cpsStmts).len
+    genTraverseProc(c, ropecg(c.p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
+    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)
@@ -98,25 +94,23 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:
-      genTraverseProc(c, dotField(accessor, "Field" & $i), a)
+      genTraverseProc(c, ropecg(c.p.module, "$1.Field$2", [accessor, i]), a)
   of tyRef:
-    visit(p, accessor, c.visitorFrmt)
+    lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
   of tySequence:
     if optSeqDestructors notin c.p.module.config.globalOptions:
-      visit(p, accessor, c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
     elif containsGarbageCollectedRef(typ.elementType):
       # destructor based seqs are themselves not traced but their data is, if
       # they contain a GC'ed type:
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisitSeq"),
-        cCast(CPointer, accessor),
-        c.visitorFrmt)
+      lineCg(p, cpsStmts, "#nimGCvisitSeq((void*)$1, $2);$n", [accessor, c.visitorFrmt])
       #genTraverseProcSeq(c, accessor, typ)
   of tyString:
     if tfHasAsgn notin typ.flags:
-      visit(p, accessor, c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
   of tyProc:
     if typ.callConv == ccClosure:
-      visit(p, dotField(accessor, "ClE_0"), c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [ropecg(c.p.module, "$1.ClE_0", [accessor]), c.visitorFrmt])
   else:
     discard
 
@@ -125,17 +119,18 @@ proc genTraverseProcSeq(c: TTraversalClosure, accessor: Rope, typ: PType) =
   assert typ.kind == tySequence
   var i = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
   var oldCode = p.s(cpsStmts)
-  var oldLen, newLen: int
+  freeze oldCode
   var a = TLoc(snippet: accessor)
-  let le = lenExpr(c.p, a)
 
-  p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), le):
-    oldLen = p.s(cpsStmts).buf.len
-    genTraverseProc(c, subscript(dataField(c.p, accessor), i.snippet), typ.elementType)
-    newLen = p.s(cpsStmts).buf.len
-  if newLen == oldLen:
+  lineF(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
+      [i.snippet, lenExpr(c.p, a)])
+  let oldLen = p.s(cpsStmts).len
+  genTraverseProc(c, "$1$3[$2]" % [accessor, i.snippet, dataField(c.p)], typ.elementType)
+  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 p = newProc(nil, m)
@@ -144,10 +139,11 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
     hcrOn = m.hcrOn
     typ = origTyp.skipTypes(abstractInstOwned)
     markerName = if hcrOn: result & "_actual" else: result
+    header = "static N_NIMCALL(void, $1)(void* p, NI op)" % [markerName]
     t = getTypeDesc(m, typ)
 
-  p.s(cpsLocals).addVar(kind = Local, name = "a", typ = t)
-  p.s(cpsInit).addAssignment("a", cCast(t, "p"))
+  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"
@@ -161,40 +157,18 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
       # C's arrays are broken beyond repair:
       genTraverseProc(c, "a".rope, typ.elementType)
     else:
-      genTraverseProc(c, cDeref("a"), typ.elementType)
+      genTraverseProc(c, "(*a)".rope, typ.elementType)
 
-  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, markerName, CVoid):
-    var paramBuilder: ProcParamBuilder
-    headerBuilder.addProcParams(paramBuilder):
-      headerBuilder.addParam(paramBuilder, name = "p", typ = CPointer)
-      headerBuilder.addParam(paramBuilder, name = "op", typ = NimInt)
-  let header = extract(headerBuilder)
+  let generatedProc = "$1 {$n$2$3$4}\n" %
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
-  m.s[cfsProcHeaders].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcHeaders].add(header)
-    m.s[cfsProcHeaders].finishProcHeaderAsProto()
-  m.s[cfsProcs].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcs].add(header)
-    m.s[cfsProcs].finishProcHeaderWithBody():
-      m.s[cfsProcs].add(extract(p.s(cpsLocals)))
-      m.s[cfsProcs].add(extract(p.s(cpsInit)))
-      m.s[cfsProcs].add(extract(p.s(cpsStmts)))
+  m.s[cfsProcHeaders].addf("$1;\n", [header])
+  m.s[cfsProcs].add(generatedProc)
 
   if hcrOn:
-    var desc = newBuilder("")
-    var unnamedParamBuilder: ProcParamBuilder
-    desc.addProcParams(unnamedParamBuilder):
-      desc.addUnnamedParam(unnamedParamBuilder, CPointer)
-      desc.addUnnamedParam(unnamedParamBuilder, NimInt)
-    let unnamedParams = extract(desc)
-    m.s[cfsProcHeaders].addProcVar(ccNimCall, result, unnamedParams, CVoid)
-    m.s[cfsDynLibInit].addAssignmentWithValue(result):
-      m.s[cfsDynLibInit].addCast(procPtrTypeUnnamed(ccNimCall, CVoid, unnamedParams)):
-        m.s[cfsDynLibInit].addCall("hcrRegisterProc",
-          getModuleDllPath(m),
-          '"' & result & '"',
-          cCast(CPointer, markerName))
+    m.s[cfsProcHeaders].addf("N_NIMCALL_PTR(void, $1)(void*, NI);\n", [result])
+    m.s[cfsDynLibInit].addf("\t$1 = (N_NIMCALL_PTR(void, )(void*, NI)) hcrRegisterProc($3, \"$1\", (void*)$2);\n",
+         [result, markerName, getModuleDllPath(m)])
 
 proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
   discard genTypeInfoV1(m, s.loc.t, info)
@@ -205,28 +179,17 @@ proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
 
   if sfThread in s.flags and emulatedThreadVars(m.config):
     accessThreadLocalVar(p, s)
-    sLoc = derefField("NimTV_", sLoc)
+    sLoc = "NimTV_->" & sLoc
 
   var c = TTraversalClosure(p: p,
-    visitorFrmt: cIntValue(0) # "#nimGCvisit((void*)$1, 0);$n"
+    visitorFrmt: "0" # "#nimGCvisit((void*)$1, 0);$n"
   )
 
+  let header = "static N_NIMCALL(void, $1)(void)" % [result]
   genTraverseProc(c, sLoc, s.loc.t)
 
-  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, result, CVoid):
-    var paramBuilder: ProcParamBuilder
-    headerBuilder.addProcParams(paramBuilder):
-      # (void)
-      discard
-  let header = extract(headerBuilder)
+  let generatedProc = "$1 {$n$2$3$4}$n" %
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
-  m.s[cfsProcHeaders].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcHeaders].add(header)
-    m.s[cfsProcHeaders].finishProcHeaderAsProto()
-  m.s[cfsProcs].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcs].add(header)
-    m.s[cfsProcs].finishProcHeaderWithBody():
-      m.s[cfsProcs].add(extract(p.s(cpsLocals)))
-      m.s[cfsProcs].add(extract(p.s(cpsInit)))
-      m.s[cfsProcs].add(extract(p.s(cpsStmts)))
+  m.s[cfsProcHeaders].addf("$1;$n", [header])
+  m.s[cfsProcs].add(generatedProc)

compiler/ccgutils.nim

@@ -11,7 +11,7 @@
 
 import
   ast, types, msgs, wordrecg,
-  platform, trees, options, cgendata, mangleutils, renderer
+  platform, trees, options, cgendata, mangleutils
 
 import std/[hashes, strutils, formatfloat]
 
@@ -90,6 +90,9 @@ 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):
@@ -117,14 +120,14 @@ proc makeUnique(m: BModule; s: PSym, name: string = ""): string =
   result.add "_u"
   result.add $s.itemId.item
 
-proc encodeSym*(m: BModule; s: PSym; makeUnique: bool = false; extra: string = ""): string =
+proc encodeSym*(m: BModule; s: PSym; makeUnique: bool = false): string =
   #Module::Type
-  var name = s.name.s & extra
+  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; staticLists: var string): string =
+proc encodeType*(m: BModule; t: PType): string =
   result = ""
   var kindName = ($t.kind)[2..^1]
   kindName[0] = toLower($kindName[0])[0]
@@ -135,10 +138,10 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
     result = encodeName(t[0].sym.name.s)
     result.add "I"
     for i in 1..<t.len - 1:
-      result.add encodeType(m, t[i], staticLists)
+      result.add encodeType(m, t[i])
     result.add "E"
   of tySequence, tyOpenArray, tyArray, tyVarargs, tyTuple, tyProc, tySet, tyTypeDesc,
-    tyPtr, tyRef, tyVar, tyLent, tySink, tyUncheckedArray, tyOr, tyAnd, tyBuiltInTypeClass:
+    tyPtr, tyRef, tyVar, tyLent, tySink, tyStatic, tyUncheckedArray, tyOr, tyAnd, tyBuiltInTypeClass:
     result =
       case t.kind:
       of tySequence: encodeName("seq")
@@ -147,13 +150,8 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
     for i in 0..<t.len:
       let s = t[i]
       if s.isNil: continue
-      result.add encodeType(m, s, staticLists)
+      result.add encodeType(m, s)
     result.add "E"
-  of tyStatic:
-    if t.n != nil:
-      staticLists.add "_s" & renderTree(t.n)
-    else:
-      raiseAssert "unreachable"
   of tyRange:
     var val = "range_"
     if t.n[0].typ.kind in {tyFloat..tyFloat128}:
@@ -166,7 +164,7 @@ proc encodeType*(m: BModule; t: PType; staticLists: var string): string =
   of tyString..tyUInt64, tyPointer, tyBool, tyChar, tyVoid, tyAnything, tyNil, tyEmpty:
     result = encodeName(kindName)
   of tyAlias, tyInferred, tyOwned:
-    result = encodeType(m, t.elementType, staticLists)
+    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
@@ -115,11 +115,11 @@ type
                         # computing alive data on our own.
 
   BModuleList* = ref object of RootObj
-    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Builder
+    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Rope
     mapping*: Rope             # the generated mapping file (if requested)
     modules*: seq[BModule]     # list of all compiled modules
     modulesClosed*: seq[BModule] # list of the same compiled modules, but in the order they were closed
-    forwardedProcs*: seq[PSym] # procs that did not yet have a body
+    forwardedProcs*: seq[PSym] # proc:s that did not yet have a body
     generatedHeader*: BModule
     typeInfoMarker*: TypeCacheWithOwner
     typeInfoMarkerV2*: TypeCacheWithOwner
@@ -127,7 +127,7 @@ type
     graph*: ModuleGraph
     strVersion*, seqVersion*: int # version of the string/seq implementation to use
 
-    nimtv*: Builder         # Nim thread vars; the struct body
+    nimtv*: Rope            # Nim thread vars; the struct body
     nimtvDeps*: seq[PType]  # type deps: every module needs whole struct
     nimtvDeclared*: IntSet  # so that every var/field exists only once
                             # in the struct
@@ -155,49 +155,45 @@ type
     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
-    queue*: seq[PSym]         # queue of procs to generate
     alive*: IntSet            # symbol IDs of alive data as computed by `dce.nim`
     headerFiles*: seq[string] # needed headers to include
     typeInfoMarker*: TypeCache # needed for generating type information
     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.
-    hcrInitGuard*: IfBuilder
     typeStack*: TTypeSeq      # used for type generation
     dataCache*: TNodeTable
     typeNodes*, nimTypes*: int # used for type info generation
     typeNodesName*, nimTypesName*: Rope # used for type info generation
     labels*: Natural          # for generating unique module-scope names
-    extensionLoaders*: array['0'..'9', Builder] # special procs for the
+    extensionLoaders*: array['0'..'9', Rope] # special procs for the
                                              # 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
 template vccAndC*(p: BProc): bool = p.module.config.cCompiler == ccVcc and p.module.config.backend == backendC
 
-proc delayedCodegen*(m: BModule): bool {.inline.} =
-  useAliveDataFromDce in m.flags or m.config.globalOptions.contains(optCompress)
-
 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:
@@ -123,8 +123,8 @@ proc attachDispatcher(s: PSym, dispatcher: PNode) =
 
 proc createDispatcher(s: PSym; g: ModuleGraph; idgen: IdGenerator): PSym =
   var disp = copySym(s, idgen)
-  incl(disp, sfDispatcher)
-  excl(disp, sfExported)
+  incl(disp.flags, sfDispatcher)
+  excl(disp.flags, sfExported)
   let old = disp.typ
   disp.typ = copyType(disp.typ, idgen, disp.typ.owner)
   copyTypeProps(g, idgen.module, disp.typ, old)
@@ -133,7 +133,7 @@ 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.locImpl.snippet = ""
+  disp.loc.snippet = ""
   if s.typ.returnType != nil:
     if disp.ast.len > resultPos:
       disp.ast[resultPos].sym = copySym(s.ast[resultPos].sym, idgen)

compiler/commands.nim

@@ -203,14 +203,13 @@ proc processSpecificNote*(arg: string, state: TSpecialWord, pass: TCmdLinePass,
   else: invalidCmdLineOption(conf, pass, orig, info)
 
   let isSomeHint = state in {wHint, wHintAsError}
-  let isSomeWarning = state in {wWarning, wWarningAsError}
   template findNote(noteMin, noteMax, name) =
     # unfortunately, hintUser and warningUser clash, otherwise implementation would simplify a bit
     let x = findStr(noteMin, noteMax, id, errUnknown)
     if x != errUnknown: notes = {TNoteKind(x)}
     else:
-      if isSomeHint or isSomeWarning:
-        message(conf, info, warnUnknownNotes, "unknown $#: $#" % [name, id])
+      if isSomeHint:
+        message(conf, info, hintUnknownHint, id)
       else:
         localError(conf, info, "unknown $#: $#" % [name, id])
   case id.normalize
@@ -364,7 +363,6 @@ proc testCompileOption*(conf: ConfigRef; switch: string, info: TLineInfo): bool
     result = false
   of "panics": result = contains(conf.globalOptions, optPanics)
   of "jsbigint64": result = contains(conf.globalOptions, optJsBigInt64)
-  of "mangle": result = contains(conf.globalOptions, optItaniumMangle)
   else:
     result = false
     invalidCmdLineOption(conf, passCmd1, switch, info)
@@ -460,7 +458,7 @@ template handleStdinOrCmdInput =
     conf.outDir = getNimcacheDir(conf)
 
 proc handleStdinInput*(conf: ConfigRef) =
-  conf.projectName = conf.stdinFile.string
+  conf.projectName = "stdinfile"
   conf.projectIsStdin = true
   handleStdinOrCmdInput()
 
@@ -474,7 +472,6 @@ proc parseCommand*(command: string): Command =
   of "cpp", "compiletocpp": cmdCompileToCpp
   of "objc", "compiletooc": cmdCompileToOC
   of "js", "compiletojs": cmdCompileToJS
-  of "nif": cmdCompileToNif
   of "r": cmdCrun
   of "m": cmdM
   of "run": cmdTcc
@@ -498,8 +495,6 @@ proc parseCommand*(command: string): Command =
   of "secret": cmdInteractive
   of "nop", "help": cmdNop
   of "jsonscript": cmdJsonscript
-  of "nifc": cmdNifC  # generate C from NIF files
-  of "deps": cmdDeps  # generate .build.nif for nifmake
   else: cmdUnknown
 
 proc setCmd*(conf: ConfigRef, cmd: Command) =
@@ -511,12 +506,6 @@ proc setCmd*(conf: ConfigRef, cmd: Command) =
   of cmdCompileToCpp: conf.backend = backendCpp
   of cmdCompileToOC: conf.backend = backendObjc
   of cmdCompileToJS: conf.backend = backendJs
-  of cmdCompileToNif: conf.backend = backendNif
-  of cmdNifC:
-    conf.backend = backendC  # NIF to C compilation
-  of cmdM:
-    # cmdM requires optCompress for proper IC handling (include files, etc.)
-    conf.globalOptions.incl optCompress
   else: discard
 
 proc setCommandEarly*(conf: ConfigRef, command: string) =
@@ -770,16 +759,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
       conf.globalOptions.excl optCDebug
     else:
       localError(conf, info, "expected native|gdb|on|off but found " & arg)
-  of "mangle":
-    case arg.normalize
-    of "nim":
-      conf.globalOptions.excl optItaniumMangle
-    of "cpp":
-      conf.globalOptions.incl optItaniumMangle
-    else:
-      localError(conf, info, "expected nim|cpp but found " & arg)
-  of "compress":
-    conf.globalOptions.incl optCompress
   of "g": # alias for --debugger:native
     conf.globalOptions.incl optCDebug
     conf.options.incl optLineDir
@@ -902,19 +881,11 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
   of "import":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      let m = findModule(conf, arg, toFullPath(conf, info)).string
-      if m.len == 0:
-        localError(conf, info, "Cannot resolve filename: " & arg)
-      else:
-        conf.implicitImports.add m
+      conf.implicitImports.add findModule(conf, arg, toFullPath(conf, info)).string
   of "include":
     expectArg(conf, switch, arg, pass, info)
     if pass in {passCmd2, passPP}:
-      let m = findModule(conf, arg, toFullPath(conf, info)).string
-      if m.len == 0:
-        localError(conf, info, "Cannot resolve filename: " & arg)
-      else:
-        conf.implicitIncludes.add m
+      conf.implicitIncludes.add findModule(conf, arg, toFullPath(conf, info)).string
   of "listcmd":
     processOnOffSwitchG(conf, {optListCmd}, arg, pass, info)
   of "asm":
@@ -948,12 +919,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     discard parseSaturatedNatural(arg, value)
     if not value > 0: localError(conf, info, "maxLoopIterationsVM must be a positive integer greater than zero")
     conf.maxLoopIterationsVM = value
-  of "maxcalldepthvm":
-    expectArg(conf, switch, arg, pass, info)
-    var value: int = 2_000
-    discard parseSaturatedNatural(arg, value)
-    if value <= 0: localError(conf, info, "maxCallDepthVM must be a positive integer greater than zero")
-    conf.maxCallDepthVM = value
   of "errormax":
     expectArg(conf, switch, arg, pass, info)
     # Note: `nim check` (etc) can overwrite this.
@@ -963,10 +928,6 @@ proc processSwitch*(switch, arg: string, pass: TCmdLinePass, info: TLineInfo;
     var value: int = 0
     discard parseSaturatedNatural(arg, value)
     conf.errorMax = if value == 0: high(int) else: value
-  of "stdinfile":
-    expectArg(conf, switch, arg, pass, info)
-    conf.stdinFile = if os.isAbsolute(arg): AbsoluteFile(arg)
-                     else: AbsoluteFile(getCurrentDir() / arg)
   of "verbosity":
     expectArg(conf, switch, arg, pass, info)
     let verbosity = parseInt(arg)

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, astalgo, semdata, lookups, lineinfos, idents, msgs, renderer, types, layeredtable
+import ast, semdata, lookups, lineinfos, idents, msgs, renderer, types, layeredtable
 
 import std/intsets
 
@@ -19,7 +19,7 @@ when defined(nimPreviewSlimSystem):
   import std/assertions
 
 const
-  logBindings = when defined(debugConcepts): true else: false
+  logBindings = false
 
 ## Code dealing with Concept declarations
 ## --------------------------------------
@@ -29,7 +29,7 @@ proc declareSelf(c: PContext; info: TLineInfo) =
   let ow = getCurrOwner(c)
   let s = newSym(skType, getIdent(c.cache, "Self"), c.idgen, ow, info)
   s.typ = newType(tyTypeDesc, c.idgen, ow)
-  s.typ.incl {tfUnresolved, tfPacked}
+  s.typ.flags.incl {tfUnresolved, tfPacked}
   s.typ.add newType(tyEmpty, c.idgen, ow)
   addDecl(c, s, info)
 
@@ -70,263 +70,88 @@ proc semConceptDeclaration*(c: PContext; n: PNode): PNode =
 ## ----------------
 
 type
-  MatchFlags* = enum
-    mfDontBind  # Do not bind generic parameters
-    mfCheckGeneric  # formal <- formal comparison as opposed to formal <- operand
-  
   MatchCon = object ## Context we pass around during concept matching.
-    bindings: LayeredIdTable
+    inferred: seq[(PType, PType)] ## we need a seq here so that we can easily undo inferences \
+      ## that turned out to be wrong.
     marker: IntSet ## Some protection against wild runaway recursions.
     potentialImplementation: PType ## the concrete type that might match the concept we try to match.
     magic: TMagic  ## mArrGet and mArrPut is wrong in system.nim and
                    ## cannot be fixed that easily.
                    ## Thus we special case it here.
-    concpt: PType  ## current concept being evaluated
-    depthCount = 0
-    flags: set[MatchFlags]
-    
-  MatchKind = enum
-    mkNoMatch, mkSubset, mkSame
-
-const
-  asymmetricConceptParamMods = {tyVar, tySink, tyLent, tyOwned, tyAlias, tyInferred} # param modifiers that to not have to match implementation -> concept
-  bindableTypes = {tyGenericParam, tyOr, tyTypeDesc}
-
-proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool
-
-proc matchType(c: PContext; fo, ao: PType; m: var MatchCon): bool
-
-proc matchReturnType(c: PContext; f, a: PType; m: var MatchCon): bool
-
-proc processConcept(c: PContext; concpt, invocation: PType, bindings: var LayeredIdTable; m: var MatchCon): bool
 
 proc existingBinding(m: MatchCon; key: PType): PType =
   ## checks if we bound the type variable 'key' already to some
   ## concrete type.
-  result = m.bindings.lookup(key)
-  if result == nil:
-    result = key
+  for i in 0..<m.inferred.len:
+    if m.inferred[i][0] == key: return m.inferred[i][1]
+  return nil
 
-const
-    ignorableForArgType = {tyVar, tySink, tyLent, tyOwned, tyAlias, tyInferred}
+proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool
 
-proc unrollGenericParam(param: PType): PType =
-  result = param.skipTypes(ignorableForArgType)
-  while result.kind in {tyGenericParam, tyTypeDesc} and result.hasElementType and result.elementType.kind != tyNone:
-    result = result.elementType
-
-proc bindParam(c: PContext, m: var MatchCon; key, v: PType): bool {. discardable .} =
-  if v.kind == tyTypeDesc:
-    return false
-  var value = unrollGenericParam(v)
-  if value.kind == tyGenericParam:
-    value = existingBinding(m, value)
-    if value.kind == tyGenericParam:
-      if value.hasElementType:
-        value = value.elementType
-      else:
-        return true
-  if value.kind == tyStatic:
-    return false
-
-  if m.magic in {mArrPut, mArrGet} and value.kind in arrPutGetMagicApplies:
-    value = value.last
-  
-  let old = existingBinding(m, key)
-  if old != key:
-    # check previously bound value
-    if not matchType(c, old, value, m):
-      return false
-  elif key.hasElementType and not key.elementType.isNil and key.elementType.kind != tyNone:
-    # check constaint
-    if matchType(c, unrollGenericParam(key), value, m) == false:
-      return false
-  
-  when logBindings: echo "bind table adding '", key, "', ", value
-  assert value != nil
-  assert value.kind != tyVoid
-  m.bindings.put(key, value)
-  return true
-
-proc defSignatureType(n: PNode): PType = n[0].sym.typ
-
-proc conceptBody*(n: PType): PNode = n.n.lastSon
-
-proc acceptsAllTypes(t: PType): bool=
-  result = false
-  if t.kind == tyAnything:
-    result = true
-  elif t.kind == tyGenericParam:
-    if tfImplicitTypeParam in t.flags:
-      result = true
-    if not t.hasElementType or t.elementType.kind == tyNone:
-      result = true
-
-proc procDefSignature(s: PSym): PNode {. deprecated .} = 
-  var nc = s.ast.copyNode()
-  for i in 0 .. 5:
-    nc.add s.ast[i]
-  nc
-
-proc matchKids(c: PContext; f, a: PType; m: var MatchCon, start=0): bool=
-  result = true
-  for i in start ..< f.kidsLen - ord(f.kind in {tyGenericInst, tyGenericInvocation}):
-    if not matchType(c, f[i], a[i], m): return false
-
-iterator traverseTyOr(t: PType): PType {. closure .}=
-  for i in t.kids:
-    case i.kind:
-    of tyGenericParam:
-      if i.hasElementType:
-        for s in traverseTyOr(i.elementType):
-          yield s
-      else:
-        yield i
-    else:
-      yield i
-
-proc matchConceptToImpl(c: PContext, f, potentialImpl: PType; m: var MatchCon): bool =
-  assert not(potentialImpl.reduceToBase.kind == tyConcept)
-  let concpt = f.reduceToBase
-  if m.depthCount > 0:
-    # concepts that are more then 2 levels deep are treated like
-    # tyAnything to stop dependencies from getting out of control
-    return true
-  var efPot = potentialImpl
-  if potentialImpl.isSelf:
-    if m.concpt.n == concpt.n:
-      return true
-    efPot = m.potentialImplementation
-  
-  var oldBindings = m.bindings
-  m.bindings = newTypeMapLayer(m.bindings)
-  let oldPotentialImplementation = m.potentialImplementation
-  m.potentialImplementation = efPot
-  let oldConcept = m.concpt
-  m.concpt = concpt
-  
-  var invocation: PType = nil
-  if f.kind in {tyGenericInvocation, tyGenericInst}:
-    invocation = f
-  inc m.depthCount
-  result = processConcept(c, concpt, invocation, oldBindings, m)
-  dec m.depthCount
-  m.potentialImplementation = oldPotentialImplementation
-  m.concpt = oldConcept
-  m.bindings = oldBindings
-
-proc cmpConceptDefs(c: PContext, fn, an: PNode, m: var MatchCon): bool=
-  if fn.kind != an.kind:
-    return false
-  if fn[namePos].sym.name != an[namePos].sym.name:
-    return false
-  let
-    ft = fn.defSignatureType
-    at = an.defSignatureType
-  if ft.len != at.len:
-    return false
-  
-  for i in 1 ..< ft.n.len:
-    m.bindings = m.bindings.newTypeMapLayer()
-    
-    let aType = at.n[i].typ
-    let fType = ft.n[i].typ
-    
-    if aType.isSelf and fType.isSelf:
-      continue
-    
-    if not matchType(c, fType, aType, m):
-      m.bindings.setToPreviousLayer()
-      return false
-  result = true
-  if not matchReturnType(c, ft.returnType, at.returnType, m):
-    m.bindings.setToPreviousLayer()
-    result = false
-
-proc conceptsMatch(c: PContext, fc, ac: PType; m: var MatchCon): MatchKind =
-  # XXX: In the future this may need extra parameters to carry info for container types
-  if fc.n == ac.n:
-    # This will have to take generic parameters into account at some point
-    return mkSame
-  let
-    fn = fc.conceptBody
-    an = ac.conceptBody
-    sameLen = fc.len == ac.len
-  var match = false
-  for fdef in fn:
-    var cmpResult = false
-    for ia, ndef in an:
-      match = cmpConceptDefs(c, fdef, ndef, m)
-      if match:
-        break
-    if not match:
-      return mkNoMatch
-  return mkSubset
-
-proc isObjectSubtype(f, a: PType): bool =
-  var t = a
-  result = false
-  while t != nil:
-    t = t.baseClass
-    if t == nil:
-      break
-    t = t.skipTypes({tyPtr,tyRef})
-    if t == nil:
-      break
-    if t.kind != tyObject:
-      break
-    if sameObjectTypes(f, t):
-      result = true
-      break
-
-proc matchType(c: PContext; fo, ao: PType; m: var MatchCon): bool =
+proc matchType(c: PContext; f, a: PType; m: var MatchCon): bool =
   ## The heart of the concept matching process. 'f' is the formal parameter of some
   ## routine inside the concept that we're looking for. 'a' is the formal parameter
   ## of a routine that might match.
-  
-  var
-    a = ao
-    f = fo
-  if a.isSelf:
-    if m.magic in {mArrPut, mArrGet}:
-      return false
-    a = m.potentialImplementation
-  if a.kind in bindableTypes:
-    a = existingBinding(m, ao)
-    if a == ao and a.kind == tyGenericParam and a.hasElementType and a.elementType.kind != tyNone:
-      a = a.elementType
-  
-  if f.isConcept:
-    if a.acceptsAllTypes:
-      return false
-    if a.skipTypes(ignorableForArgType).isConcept:
-      # if f is a subset of a then any match to a will also match f. Not the other way around
-      return conceptsMatch(c, a.reduceToBase, f.reduceToBase, m) >= mkSubset
-    else:
-      return matchConceptToImpl(c, f, a, m)
-  
-  result = false
-
+  const
+    ignorableForArgType = {tyVar, tySink, tyLent, tyOwned, tyGenericInst, tyAlias, tyInferred}
   case f.kind
   of tyAlias:
     result = matchType(c, f.skipModifier, a, m)
   of tyTypeDesc:
     if isSelf(f):
-      let ua = a.skipTypes(asymmetricConceptParamMods)
-      if m.magic in {mArrPut, mArrGet}:
-        if m.potentialImplementation.reduceToBase.kind in arrPutGetMagicApplies:
-          bindParam(c, m, a, last m.potentialImplementation)
-          result = true
-      #elif ua.isConcept:
-      #  result = matchType(c, m.concpt, ua, m)
-      else:
-        result = matchType(c, a.skipTypes(ignorableForArgType), m.potentialImplementation, m)
+      #let oldLen = m.inferred.len
+      result = matchType(c, a, m.potentialImplementation, m)
+      #echo "self is? ", result, " ", a.kind, " ", a, " ", m.potentialImplementation, " ", m.potentialImplementation.kind
+      #m.inferred.setLen oldLen
+      #echo "A for ", result, " to ", typeToString(a), " to ", typeToString(m.potentialImplementation)
     else:
-      if a.kind == tyTypeDesc:
-        if not(a.hasElementType) or a.elementType.kind == tyNone:
-          result = true
-        elif f.hasElementType:
+      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
+      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 not matchType(c, f[i], a[i], m): return false
+        return true
+  of tyGenericParam:
+    let ak = a.skipTypes({tyVar, tySink, tyLent, tyOwned})
+    if ak.kind in {tyTypeDesc, tyStatic} and not isSelf(ak):
+      result = false
+    else:
+      let old = existingBinding(m, f)
+      if old == nil:
+        if f.hasElementType and f.elementType.kind != tyNone:
+          # also check the generic's constraints:
+          let oldLen = m.inferred.len
+          result = matchType(c, f.elementType, 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))
+          result = true
+        else:
+          when logBindings: echo "C adding ", f, " ", ak
+          m.inferred.add((f, ak))
+          #echo "binding ", typeToString(ak), " to ", typeToString(f)
+          result = true
+      elif not m.marker.containsOrIncl(old.id):
+        result = matchType(c, old, ak, m)
+        if m.magic == mArrPut and ak.kind == tyGenericParam:
+          result = true
+      else:
+        result = false
+    #echo "B for ", result, " to ", typeToString(a), " to ", typeToString(m.potentialImplementation)
+
   of tyVar, tySink, tyLent, tyOwned:
     # modifiers in the concept must be there in the actual implementation
     # too but not vice versa.
@@ -334,136 +159,70 @@ proc matchType(c: PContext; fo, ao: PType; m: var MatchCon): bool =
       result = matchType(c, f.elementType, a.elementType, m)
     elif m.magic == mArrPut:
       result = matchType(c, f.elementType, a, m)
-  of tyEnum, tyObject, tyDistinct:
-    if a.kind in ignorableForArgType:
-      result = matchType(c, f, a.skipTypes(ignorableForArgType), m)
     else:
-      if a.kind == tyGenericInst:
-        # tyOr does this to generic typeclasses
-        result = a.base.sym == f.sym
-      else:
-        result = sameType(f, a)
-      if not result and f.kind == tyObject and a.kind == tyObject:
-        result = isObjectSubtype(f, a)
+      result = false
+  of tyEnum, tyObject, tyDistinct:
+    result = sameType(f, a)
   of tyEmpty, tyString, tyCstring, tyPointer, tyNil, tyUntyped, tyTyped, tyVoid:
     result = a.skipTypes(ignorableForArgType).kind == f.kind
   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)
-  of tyArray, tyTuple, tyVarargs, tyOpenArray, tyRange, tySequence, tyRef, tyPtr:
-    if f.kind == tyArray and f.kidsLen == 3 and a.kind == tyArray:
-      # XXX: this is a work-around!
-      # system.nim creates these for the magic array typeclass
-      result = true
-    else:
-      let ak = a.skipTypes(ignorableForArgType - {f.kind})
-      if ak.kind == f.kind:
-        if f.base.kind == tyNone:
-          result = true
-        elif f.kidsLen == ak.kidsLen:
-          result = matchKids(c, f, ak, m)
-  of tyGenericInvocation, tyGenericInst:
+       (ak.kind == tyGenericParam and ak.hasElementType and ak.elementType.kind == tyOrdinal)
+  of tyConcept:
+    let oldLen = m.inferred.len
+    let oldPotentialImplementation = m.potentialImplementation
+    m.potentialImplementation = a
+    result = conceptMatchNode(c, f.n.lastSon, m)
+    m.potentialImplementation = oldPotentialImplementation
+    if not result:
+      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 ea = a.skipTypes(ignorableForArgType)
-    if ea.kind in {tyGenericInst, tyGenericInvocation}:
-      var
-        k1 = f.kidsLen - ord(f.kind == tyGenericInst)
-        k2 = ea.kidsLen - ord(ea.kind == tyGenericInst)
-      if sameType(f.genericHead, ea.genericHead) and k1 == k2:
-        result = true
-        for i in 1 ..< k2:
-          if not matchType(c, f[i], ea[i], m):
-            result = false
-            break
-    elif f.kind == tyGenericInvocation:
-      # bind potential generic constraints into body
-      let body = f.base
-      for i in 1 ..< len(f):
-        bindParam(c,m,body[i-1], f[i])
-      result = matchType(c, body, a, m)
-    else: # tyGenericInst
-      result = matchType(c, f.last, a, m)
-  of tyOrdinal:
-    result = isOrdinalType(a, allowEnumWithHoles = false) or a.kind == tyGenericParam
-  of tyStatic:
-    var scomp = f.base
-    if scomp.kind == tyGenericParam:
-      if f.base.kidsLen > 0:
-        scomp = scomp.base
-    if a.kind == tyStatic:
-      result = matchType(c, scomp, a.base, m)
-    else:
-      result = matchType(c, scomp, a, m)
-  of tyGenericParam:
-    if a.acceptsAllTypes:
-      discard bindParam(c, m, f, a)
-      result = f.acceptsAllTypes
-    else:
-      result = bindParam(c, m, f, a)
-  of tyAnything:
-    result = true
-  of tyNot:
-    if a.kind == tyNot:
-      result = matchType(c, f.elementType, a.elementType, m)
-    else:
-      m.bindings = m.bindings.newTypeMapLayer()
-      result = not matchType(c, f.elementType, a, m)
-      m.bindings.setToPreviousLayer()
-  of tyAnd:
-    m.bindings = m.bindings.newTypeMapLayer()
-    result = true
-    for ff in traverseTyOr(f):
-      let r = matchType(c, ff, a, m)
-      if not r:
-        m.bindings.setToPreviousLayer()
-        result = false
-        break
-  of tyGenericBody:
-    var ak = a
-    if a.kind == tyGenericBody:
-      ak = last(a)
-    result = matchType(c, last(f), ak, m)
-  of tyCompositeTypeClass:
-    if a.kind == tyCompositeTypeClass:
-      result = matchKids(c, f, a, m)
-    else:
-      result = matchType(c, last(f), a, m)
-  of tyBuiltInTypeClass:
-    let target = f.genericHead.kind
-    result = a.skipTypes(ignorableForArgType).reduceToBase.kind == target
+    let ak = a.skipTypes(ignorableForArgType - {f.kind})
+    if ak.kind == f.kind and f.kidsLen == ak.kidsLen:
+      for i in 0..<ak.kidsLen:
+        if not matchType(c, f[i], ak[i], m): return false
+      return true
   of tyOr:
+    let oldLen = m.inferred.len
     if a.kind == tyOr:
+      # say the concept requires 'int|float|string' if the potentialImplementation
+      # says 'int|string' that is good enough.
       var covered = 0
-      for ff in traverseTyOr(f):
-        for aa in traverseTyOr(a):
-          m.bindings = m.bindings.newTypeMapLayer()
+      for ff in f.kids:
+        for aa in a.kids:
+          let oldLenB = m.inferred.len
           let r = matchType(c, ff, aa, m)
           if r:
             inc covered
             break
-          m.bindings.setToPreviousLayer()
+          m.inferred.setLen oldLenB
 
       result = covered >= a.kidsLen
+      if not result:
+        m.inferred.setLen oldLen
     else:
+      result = false
       for ff in f.kids:
-        m.bindings = m.bindings.newTypeMapLayer()
         result = matchType(c, ff, a, m)
         if result: break # and remember the binding!
-        m.bindings.setToPreviousLayer()
-  of tySet:
-    result = false
-    if a.kind == tySet:
+        m.inferred.setLen oldLen
+  of tyNot:
+    if a.kind == tyNot:
       result = matchType(c, f.elementType, a.elementType, m)
+    else:
+      let oldLen = m.inferred.len
+      result = not matchType(c, f.elementType, a, m)
+      m.inferred.setLen oldLen
+  of tyAnything:
+    result = true
+  of tyOrdinal:
+    result = isOrdinalType(a, allowEnumWithHoles = false) or a.kind == tyGenericParam
   else:
     result = false
-  if result and ao.kind == tyGenericParam:
-    let bf = if f.isSelf: m.potentialImplementation else: f
-    if bindParam(c, m, ao, bf):
-      when logBindings: echo " ^ reverse binding"
-
-proc checkConstraint(c: PContext; f, a: PType; m: var MatchCon): bool =
-  result = matchType(c, f, a, m) or matchType(c, a, f, m)
 
 proc matchReturnType(c: PContext; f, a: PType; m: var MatchCon): bool =
   ## Like 'matchType' but with extra logic dealing with proc return types
@@ -473,38 +232,30 @@ proc matchReturnType(c: PContext; f, a: PType; m: var MatchCon): bool =
   elif a == nil:
     result = false
   else:
-    result = checkConstraint(c, f, a, m)
+    result = matchType(c, f, a, m)
 
 proc matchSym(c: PContext; candidate: PSym, n: PNode; m: var MatchCon): bool =
   ## Checks if 'candidate' matches 'n' from the concept body. 'n' is a nkProcDef
   ## or similar.
 
   # watch out: only add bindings after a completely successful match.
-  m.bindings = m.bindings.newTypeMapLayer()
+  let oldLen = m.inferred.len
 
   let can = candidate.typ.n
-  let con = defSignatureType(n).n
+  let con = n[0].sym.typ.n
+
   if can.len < con.len:
     # too few arguments, cannot be a match:
     return false
-  
-  if can.len > con.len:
-    # too many arguments (not optional)
-    for i in con.len ..< can.len:
-      if can[i].sym.ast == nil:
-        return false
-  
-  when defined(debugConcepts):
-    echo "considering: ", renderTree(candidate.procDefSignature), " ", candidate.magic
-  
+
   let common = min(can.len, con.len)
   for i in 1 ..< common:
-    if not checkConstraint(c, con[i].typ, can[i].typ, m):
-      m.bindings.setToPreviousLayer()
+    if not matchType(c, con[i].typ, can[i].typ, m):
+      m.inferred.setLen oldLen
       return false
-  
-  if not matchReturnType(c, n.defSignatureType.returnType, candidate.typ.returnType, m):
-    m.bindings.setToPreviousLayer()
+
+  if not matchReturnType(c, n[0].sym.typ.returnType, candidate.typ.returnType, m):
+    m.inferred.setLen oldLen
     return false
 
   # all other parameters have to be optional parameters:
@@ -512,7 +263,7 @@ proc matchSym(c: PContext; candidate: PSym, n: PNode; m: var MatchCon): bool =
     assert can[i].kind == nkSym
     if can[i].sym.ast == nil:
       # has too many arguments one of which is not optional:
-      m.bindings.setToPreviousLayer()
+      m.inferred.setLen oldLen
       return false
 
   return true
@@ -520,14 +271,12 @@ proc matchSym(c: PContext; candidate: PSym, n: PNode; m: var MatchCon): bool =
 proc matchSyms(c: PContext, n: PNode; kinds: set[TSymKind]; m: var MatchCon): bool =
   ## Walk the current scope, extract candidates which the same name as 'n[namePos]',
   ## 'n' is the nkProcDef or similar from the concept that we try to match.
-  result = false
-  var candidates = searchScopes(c, n[namePos].sym.name, kinds)
-  searchImportsAll(c, n[namePos].sym.name, kinds, candidates)
+  let candidates = searchInScopesAllCandidatesFilterBy(c, n[namePos].sym.name, kinds)
   for candidate in candidates:
+    #echo "considering ", typeToString(candidate.typ), " ", candidate.magic
     m.magic = candidate.magic
-    if matchSym(c, candidate, n, m):
-      result = true
-      break
+    if matchSym(c, candidate, n, m): return true
+  result = false
 
 proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool =
   ## Traverse the concept's AST ('n') and see if every declaration inside 'n'
@@ -560,48 +309,7 @@ proc conceptMatchNode(c: PContext; n: PNode; m: var MatchCon): bool =
     # error was reported earlier.
     result = false
 
-proc fixBindings(bindings: var LayeredIdTable; concpt: PType; invocation: PType; m: var MatchCon) =
-  # invocation != nil means we have a non-atomic concept:
-  if invocation != nil and invocation.kind == tyGenericInvocation:
-    assert concpt.sym.typ.kind == tyGenericBody
-    
-    for i in 0 .. concpt.sym.typ.len - 1:
-      let thisSym = concpt.sym.typ[i]
-      if lookup(bindings, thisSym) != nil:
-        # dont trust the bindings over existing ones
-        continue
-      let found = m.bindings.lookup(thisSym)
-      if found != nil:
-        when logBindings: echo "Invocation bind: ", thisSym, " ", found
-        bindings.put(thisSym, found)
-    
-    # bind even more generic parameters
-    let genBody = invocation.base
-    assert genBody.kind == tyGenericBody
-    for i in FirstGenericParamAt ..< invocation.kidsLen:
-      let bpram = genBody[i - 1]
-      if lookup(bindings, invocation[i]) != nil:
-        # dont trust the bindings over existing ones
-        continue
-      let boundV = lookup(bindings, bpram)
-      when logBindings: echo "generic body bind: '", invocation[i], "' '", boundV, "'"
-      if boundV != nil:
-        bindings.put(invocation[i], boundV)
-  bindings.put(concpt, m.potentialImplementation)
-
-proc processConcept(c: PContext; concpt, invocation: PType, bindings: var LayeredIdTable; m: var MatchCon): bool =
-  m.bindings = m.bindings.newTypeMapLayer()
-  if invocation != nil and invocation.kind == tyGenericInst:
-    let genericBody = invocation.base
-    for i in 1..<invocation.kidsLen-1:
-      # instGenericContainer can bind `tyVoid`
-      if invocation[i].kind != tyVoid:
-        bindParam(c, m, genericBody[i-1], invocation[i])
-  result = conceptMatchNode(c, concpt.conceptBody, m)
-  if result and mfDontBind notin m.flags:
-    fixBindings(bindings, concpt, invocation, m)
-
-proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable; invocation: PType, flags: set[MatchFlags] = {}): bool =
+proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable; 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
   ## concept's requirements. If so, we return true and fill the 'bindings' with pairs of
@@ -610,16 +318,26 @@ proc conceptMatch*(c: PContext; concpt, arg: PType; bindings: var LayeredIdTable
   ## `C[S, T]` parent type that we look for. We need this because we need to store bindings
   ## for 'S' and 'T' inside 'bindings' on a successful match. It is very important that
   ## we do not add any bindings at all on an unsuccessful match!
-  var m = MatchCon(bindings: bindings, potentialImplementation: arg, concpt: concpt, flags: flags)
-  if arg.isConcept:
-    result = conceptsMatch(c, concpt.reduceToBase, arg.reduceToBase, m) >= mkSubset
-  elif arg.acceptsAllTypes:
-    # XXX: I think this is wrong, or at least partially wrong. Can still test ambiguous types
-    result = false
-  elif mfCheckGeneric in m.flags:
-    # prioritize concepts the least. Specifically if the arg is not a catch all as per above
-    result = true
-  else:
-    result = processConcept(c, concpt, invocation, bindings, m)
-
-  
+  var m = MatchCon(inferred: @[], potentialImplementation: arg)
+  result = conceptMatchNode(c, concpt.n.lastSon, m)
+  if result:
+    for (a, b) in m.inferred:
+      if b.kind == tyGenericParam:
+        var dest = b
+        while true:
+          dest = existingBinding(m, dest)
+          if dest == nil or dest.kind != tyGenericParam: break
+        if dest != nil:
+          bindings.put(a, dest)
+          when logBindings: echo "A bind ", a, " ", dest
+      else:
+        bindings.put(a, b)
+        when logBindings: echo "B bind ", a, " ", b
+    # we have a match, so bind 'arg' itself to 'concpt':
+    bindings.put(concpt, arg)
+    # invocation != nil means we have a non-atomic concept:
+    if invocation != nil and arg.kind == tyGenericInst and invocation.kidsLen == arg.kidsLen-1:
+      # bind even more generic parameters
+      assert invocation.kind == tyGenericInvocation
+      for i in FirstGenericParamAt ..< invocation.kidsLen:
+        bindings.put(invocation[i], arg[i])

compiler/condsyms.nim

@@ -159,7 +159,7 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasEnsureMove")
   defineSymbol("nimHasNoReturnError")
 
-  defineSymbol("nimUseStrictDefs") # deadcode
+  defineSymbol("nimUseStrictDefs")
   defineSymbol("nimHasNolineTooLong")
 
   defineSymbol("nimHasCastExtendedVm")
@@ -171,7 +171,3 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasJsNoLambdaLifting")
   defineSymbol("nimHasDefaultFloatRoundtrip")
   defineSymbol("nimHasXorSet")
-
-  defineSymbol("nimHasSetLengthSeqUninitMagic")
-  defineSymbol("nimHasPreviewDuplicateModuleError")
-

compiler/deps.nim

@@ -1,340 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2025 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Generate a .build.nif file for nifmake from a Nim project.
-## This enables incremental and parallel compilation using the `m` switch.
-
-import std / [os, tables, sets, times, osproc, strutils]
-import options, msgs, pathutils, lineinfos
-
-import "../dist/nimony/src/lib" / [nifstreams, nifcursors, bitabs, nifreader, nifbuilder]
-import "../dist/nimony/src/gear2" / modnames
-
-type
-  FilePair = object
-    nimFile: string
-    modname: string
-
-  Node = ref object
-    files: seq[FilePair]  # main file + includes
-    deps: seq[int]        # indices into DepContext.nodes
-    id: int
-
-  DepContext = object
-    config: ConfigRef
-    nifler: string
-    nodes: seq[Node]
-    processedModules: Table[string, int]  # modname -> node index
-    includeStack: seq[string]
-
-proc toPair(c: DepContext; f: string): FilePair =
-  FilePair(nimFile: f, modname: moduleSuffix(f, cast[seq[string]](c.config.searchPaths)))
-
-proc depsFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".deps.nif"
-
-proc parsedFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".p.nif"
-
-proc semmedFile(c: DepContext; f: FilePair): string =
-  getNimcacheDir(c.config).string / f.modname & ".nif"
-
-proc findNifler(): string =
-  # Look for nifler in common locations
-  result = findExe("nifler")
-  if result.len == 0:
-    # Try relative to nim executable
-    let nimDir = getAppDir()
-    result = nimDir / "nifler"
-    if not fileExists(result):
-      result = nimDir / ".." / "nimony" / "bin" / "nifler"
-      if not fileExists(result):
-        result = ""
-
-proc runNifler(c: DepContext; nimFile: string): bool =
-  ## Run nifler deps on a file if needed. Returns true on success.
-  let pair = c.toPair(nimFile)
-  let depsPath = c.depsFile(pair)
-
-  # Check if deps file is up-to-date
-  if fileExists(depsPath) and fileExists(nimFile):
-    if getLastModificationTime(depsPath) > getLastModificationTime(nimFile):
-      return true  # Already up-to-date
-
-  # Create output directory if needed
-  createDir(parentDir(depsPath))
-
-  # Run nifler deps
-  let cmd = quoteShell(c.nifler) & " deps " & quoteShell(nimFile) & " " & quoteShell(depsPath)
-  let exitCode = execShellCmd(cmd)
-  result = exitCode == 0
-
-proc resolveFile(c: DepContext; origin, toResolve: string): string =
-  ## Resolve an import path relative to origin file
-  # Handle std/ prefix
-  var path = toResolve
-  if path.startsWith("std/"):
-    path = path.substr(4)
-
-  # Try relative to origin first
-  let originDir = parentDir(origin)
-  result = originDir / path.addFileExt("nim")
-  if fileExists(result):
-    return result
-
-  # Try search paths
-  for searchPath in c.config.searchPaths:
-    result = searchPath.string / path.addFileExt("nim")
-    if fileExists(result):
-      return result
-
-  result = ""
-
-proc traverseDeps(c: var DepContext; pair: FilePair; current: Node)
-
-proc processInclude(c: var DepContext; includePath: string; current: Node) =
-  let resolved = resolveFile(c, current.files[current.files.len - 1].nimFile, includePath)
-  if resolved.len == 0 or not fileExists(resolved):
-    return
-
-  # Check for recursive includes
-  for s in c.includeStack:
-    if s == resolved:
-      return  # Skip recursive include
-
-  c.includeStack.add resolved
-  current.files.add c.toPair(resolved)
-  traverseDeps(c, c.toPair(resolved), current)
-  discard c.includeStack.pop()
-
-proc processImport(c: var DepContext; importPath: string; current: Node) =
-  let resolved = resolveFile(c, current.files[0].nimFile, importPath)
-  if resolved.len == 0 or not fileExists(resolved):
-    return
-
-  let pair = c.toPair(resolved)
-  let existingIdx = c.processedModules.getOrDefault(pair.modname, -1)
-
-  if existingIdx == -1:
-    # New module - create node and process it
-    let newNode = Node(files: @[pair], id: c.nodes.len)
-    current.deps.add newNode.id
-    c.processedModules[pair.modname] = newNode.id
-    c.nodes.add newNode
-    traverseDeps(c, pair, newNode)
-  else:
-    # Already processed - just add dependency
-    if existingIdx notin current.deps:
-      current.deps.add existingIdx
-
-proc readDepsFile(c: var DepContext; pair: FilePair; current: Node) =
-  ## Read a .deps.nif file and process imports/includes
-  let depsPath = c.depsFile(pair)
-  if not fileExists(depsPath):
-    return
-
-  var s = nifstreams.open(depsPath)
-  defer: nifstreams.close(s)
-  discard processDirectives(s.r)
-
-  var t = next(s)
-  if t.kind != ParLe:
-    return
-
-  # Skip to content (past stmts tag)
-  t = next(s)
-
-  while t.kind != EofToken:
-    if t.kind == ParLe:
-      let tag = pool.tags[t.tagId]
-      case tag
-      of "import", "fromimport":
-        # Read import path
-        t = next(s)
-        # Check for "when" marker (conditional import)
-        if t.kind == Ident and pool.strings[t.litId] == "when":
-          t = next(s)  # skip it, still process the import
-        # Handle path expression (could be ident, string, or infix like std/foo)
-        var importPath = ""
-        if t.kind == Ident:
-          importPath = pool.strings[t.litId]
-        elif t.kind == StringLit:
-          importPath = pool.strings[t.litId]
-        elif t.kind == ParLe and pool.tags[t.tagId] == "infix":
-          # Handle std / foo style imports
-          t = next(s)  # skip infix tag
-          if t.kind == Ident:  # operator (/)
-            t = next(s)
-          if t.kind == Ident:  # first part (std)
-            importPath = pool.strings[t.litId]
-            t = next(s)
-          if t.kind == Ident:  # second part (foo)
-            importPath = importPath & "/" & pool.strings[t.litId]
-        if importPath.len > 0:
-          processImport(c, importPath, current)
-        # Skip to end of import node
-        var depth = 1
-        while depth > 0:
-          t = next(s)
-          if t.kind == ParLe: inc depth
-          elif t.kind == ParRi: dec depth
-      of "include":
-        # Read include path
-        t = next(s)
-        if t.kind == Ident and pool.strings[t.litId] == "when":
-          t = next(s)  # skip conditional marker
-        var includePath = ""
-        if t.kind == Ident:
-          includePath = pool.strings[t.litId]
-        elif t.kind == StringLit:
-          includePath = pool.strings[t.litId]
-        if includePath.len > 0:
-          processInclude(c, includePath, current)
-        # Skip to end
-        var depth = 1
-        while depth > 0:
-          t = next(s)
-          if t.kind == ParLe: inc depth
-          elif t.kind == ParRi: dec depth
-      else:
-        # Skip unknown node
-        var depth = 1
-        while depth > 0:
-          t = next(s)
-          if t.kind == ParLe: inc depth
-          elif t.kind == ParRi: dec depth
-    t = next(s)
-
-proc traverseDeps(c: var DepContext; pair: FilePair; current: Node) =
-  ## Process a module: run nifler and read deps
-  if not runNifler(c, pair.nimFile):
-    rawMessage(c.config, errGenerated, "nifler failed for: " & pair.nimFile)
-    return
-  readDepsFile(c, pair, current)
-
-proc generateBuildFile(c: DepContext): string =
-  ## Generate the .build.nif file for nifmake
-  result = getNimcacheDir(c.config).string / c.nodes[0].files[0].modname & ".build.nif"
-
-  var b = nifbuilder.open(result)
-  defer: b.close()
-
-  b.addHeader("nim deps", "nifmake")
-  b.addTree "stmts"
-
-  # Define nifler command
-  b.addTree "cmd"
-  b.addSymbolDef "nifler"
-  b.addStrLit c.nifler
-  b.addStrLit "parse"
-  b.addStrLit "--deps"
-  b.addTree "input"
-  b.endTree()
-  b.addTree "output"
-  b.endTree()
-  b.endTree()
-
-  # Define nim m command
-  b.addTree "cmd"
-  b.addSymbolDef "nim_m"
-  b.addStrLit getAppFilename()
-  b.addStrLit "m"
-  # Add search paths
-  for p in c.config.searchPaths:
-    b.addStrLit "--path:" & p.string
-  b.addTree "input"
-  b.addIntLit 0
-  b.endTree()
-  b.endTree()
-
-  # Build rules for parsing (nifler)
-  var seenFiles = initHashSet[string]()
-  for node in c.nodes:
-    for pair in node.files:
-      let parsed = c.parsedFile(pair)
-      if not seenFiles.containsOrIncl(parsed):
-        b.addTree "do"
-        b.addIdent "nifler"
-        b.addTree "input"
-        b.addStrLit pair.nimFile
-        b.endTree()
-        b.addTree "output"
-        b.addStrLit parsed
-        b.endTree()
-        b.addTree "output"
-        b.addStrLit c.depsFile(pair)
-        b.endTree()
-        b.endTree()
-
-  # Build rules for semantic checking (nim m)
-  for i in countdown(c.nodes.len - 1, 0):
-    let node = c.nodes[i]
-    let pair = node.files[0]
-    b.addTree "do"
-    b.addIdent "nim_m"
-    # Input: all parsed files for this module
-    for f in node.files:
-      b.addTree "input"
-      b.addStrLit c.parsedFile(f)
-      b.endTree()
-    # Also depend on semmed files of dependencies
-    for depIdx in node.deps:
-      b.addTree "input"
-      b.addStrLit c.semmedFile(c.nodes[depIdx].files[0])
-      b.endTree()
-    # Output: semmed file
-    b.addTree "output"
-    b.addStrLit c.semmedFile(pair)
-    b.endTree()
-    b.addTree "args"
-    b.addStrLit pair.nimFile
-    b.endTree()
-    b.endTree()
-
-  b.endTree()  # stmts
-
-proc commandDeps*(conf: ConfigRef) =
-  ## Main entry point for `nim deps`
-  when not defined(nimKochBootstrap):
-    let nifler = findNifler()
-    if nifler.len == 0:
-      rawMessage(conf, errGenerated, "nifler tool not found. Install nimony or add nifler to PATH.")
-      return
-
-    let projectFile = conf.projectFull.string
-    if not fileExists(projectFile):
-      rawMessage(conf, errGenerated, "project file not found: " & projectFile)
-      return
-
-    # Create nimcache directory
-    createDir(getNimcacheDir(conf).string)
-
-    var c = DepContext(
-      config: conf,
-      nifler: nifler,
-      nodes: @[],
-      processedModules: initTable[string, int](),
-      includeStack: @[]
-    )
-
-    # Create root node for main project file
-    let rootPair = c.toPair(projectFile)
-    let rootNode = Node(files: @[rootPair], id: 0)
-    c.nodes.add rootNode
-    c.processedModules[rootPair.modname] = 0
-
-    # Process dependencies
-    traverseDeps(c, rootPair, rootNode)
-
-    # Generate build file
-    let buildFile = generateBuildFile(c)
-    rawMessage(conf, hintSuccess, "generated: " & buildFile)
-    rawMessage(conf, hintSuccess, "run: nifmake run " & buildFile)
-  else:
-    rawMessage(conf, errGenerated, "nim deps not available in bootstrap build")

compiler/dfa.nim

@@ -439,8 +439,8 @@ proc gen(c: var Con; n: PNode) =
     genUse(c, n)
   of nkIfStmt, nkIfExpr: genIf(c, n)
   of nkWhenStmt:
-    # This is "when nimvm" node. Chose the second branch.
-    gen(c, n[1][0])
+    # This is "when nimvm" node. Chose the first branch.
+    gen(c, n[0][1])
   of nkCaseStmt: genCase(c, n)
   of nkWhileStmt: genWhile(c, n)
   of nkBlockExpr, nkBlockStmt: genBlock(c, n)

compiler/docgen.nim

@@ -1320,7 +1320,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,14 +1406,11 @@ proc generateDoc*(d: PDoc, n, orig: PNode, config: ConfigRef, docFlags: DocFlags
     for it in n: traceDeps(d, it)
   of nkExportStmt:
     for it in n:
-      if it.kind == nkSym:
-        if d.module != nil and d.module == it.sym.owner:  # in current module
-          # bug #23051; don't generate documentation for exported symbols again
-          if sfExported notin it.sym.flags:
-            generateDoc(d, it.sym.ast, orig, config, kForceExport)
-          # else it's to be handled in `of XxxSection` branch
+      # bug #23051; don't generate documentation for exported symbols again
+      if it.kind == nkSym and sfExported notin it.sym.flags:
+        if d.module != nil and d.module == it.sym.owner:
+          generateDoc(d, it.sym.ast, orig, config, kForceExport)
         elif it.sym.ast != nil:
-          # only export symbols in imported modules, not in current module
           exportSym(d, it.sym)
   of nkExportExceptStmt: discard "transformed into nkExportStmt by semExportExcept"
   of nkFromStmt, nkImportExceptStmt: traceDeps(d, n[0])
@@ -1892,9 +1889,6 @@ proc commandJson*(cache: IdentCache, conf: ConfigRef) =
   else:
     #echo getOutFile(gProjectFull, JsonExt)
     let filename = getOutFile(conf, RelativeFile conf.projectName, JsonExt)
-    conf.outFile = filename.relativeTo(conf.outDir)
-    let dir = filename.splitFile.dir
-    createDir(dir)
     try:
       writeFile(filename, content)
     except IOError:
@@ -1915,10 +1909,8 @@ proc commandTags*(cache: IdentCache, conf: ConfigRef) =
   if optStdout in d.conf.globalOptions:
     write(stdout, content)
   else:
+    #echo getOutFile(gProjectFull, TagsExt)
     let filename = getOutFile(conf, RelativeFile conf.projectName, TagsExt)
-    conf.outFile = filename.relativeTo(conf.outDir)
-    let dir = filename.splitFile.dir
-    createDir(dir)
     try:
       writeFile(filename, content)
     except IOError:

compiler/enumtostr.nim

@@ -33,10 +33,6 @@ proc genEnumToStrProc*(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGener
     caseStmt.add newTree(nkOfBranch, newIntTypeNode(field.position, t),
       newTree(nkStmtList, newTree(nkFastAsgn, newSymNode(res), newStrNode(val, info))))
     #newIntTypeNode(nkIntLit, field.position, t)
-  # safety branch for invalid data:
-  caseStmt.add newTree(nkElse,
-    newTree(nkStmtList, newTree(nkFastAsgn, newSymNode(res),
-      newStrNode("", info))))
 
   body.add(caseStmt)
 
@@ -47,7 +43,8 @@ proc genEnumToStrProc*(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGener
   n[bodyPos] = body
   n[resultPos] = newSymNode(res)
   result.ast = n
-  incl result.flagsImpl, {sfFromGeneric, sfNeverRaises}
+  incl result.flags, sfFromGeneric
+  incl result.flags, sfNeverRaises
 
 proc searchObjCaseImpl(obj: PNode; field: PSym): PNode =
   case obj.kind
@@ -109,4 +106,5 @@ proc genCaseObjDiscMapping*(t: PType; field: PSym; info: TLineInfo; g: ModuleGra
   n[bodyPos] = body
   n[resultPos] = newSymNode(res)
   result.ast = n
-  incl result.flagsImpl, {sfFromGeneric, sfNeverRaises}
+  incl result.flags, sfFromGeneric
+  incl result.flags, sfNeverRaises

compiler/evalffi.nim

@@ -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,7 +298,7 @@ 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
@@ -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)
@@ -427,7 +427,7 @@ 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
 
@@ -481,7 +481,7 @@ proc callForeignFunction*(conf: ConfigRef, fn: PNode, fntyp: PType,
     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

@@ -182,7 +182,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;

compiler/extccomp.nim

@@ -257,8 +257,8 @@ compiler tcc:
     linkerExe: "tcc",
     linkTmpl: "-o $exefile $options $buildgui $builddll $objfiles",
     includeCmd: " -I",
-    linkDirCmd: " -L",
-    linkLibCmd: " -l$1",
+    linkDirCmd: "", # XXX: not supported yet
+    linkLibCmd: "", # XXX: not supported yet
     debug: " -g ",
     pic: "",
     asmStmtFrmt: "asm($1);$n",
@@ -341,7 +341,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, backendNif: discard
+  of backendC: discard
   of backendInvalid:
     # during parsing of cfg files; we don't know the backend yet, no point in
     # guessing wrong thing
@@ -474,11 +474,6 @@ proc noAbsolutePaths(conf: ConfigRef): bool {.inline.} =
 proc cFileSpecificOptions(conf: ConfigRef; nimname, fullNimFile: string): string =
   result = conf.compileOptions
 
-  if (conf.cCompiler == ccGcc or conf.cCompiler == ccCLang) and
-       conf.selectedGC == gcRefc:
-    # bug #10625
-    addOpt(result, "-fno-omit-frame-pointer")
-
   for option in conf.compileOptionsCmd:
     if strutils.find(result, option, 0) < 0:
       addOpt(result, option)
@@ -810,59 +805,6 @@ template tryExceptOSErrorMessage(conf: ConfigRef; errorPrefix: string = "", body
         (ose.msg & " " & $ose.errorCode))
     raise
 
-proc createMacAppBundle(conf: ConfigRef; exefile: AbsoluteFile) =
-  let (dir, name, _) = splitFile(exefile.string)
-  let appBundleName = name & ".app"
-  let appBundlePath = dir / appBundleName
-  let contentsPath = appBundlePath / "Contents"
-  let macosPath = contentsPath / "MacOS"
-
-  createDir(macosPath)
-
-  let bundleExePath = macosPath / name
-  copyFileWithPermissions(exefile.string, bundleExePath)
-
-  let infoPlistPath = contentsPath / "Info.plist"
-
-  proc xmlEscape(s: string): string =
-    result = newStringOfCap(s.len)
-    for c in items(s):
-      case c:
-      of '<': result.add("&lt;")
-      of '>': result.add("&gt;")
-      of '&': result.add("&amp;")
-      of '"': result.add("&quot;")
-      of '\'': result.add("&apos;")
-      else:
-        if ord(c) < 32:
-          result.add("&#" & $ord(c) & ';')
-        else:
-          result.add(c)
-
-  let escapedName = xmlEscape(name)
-  let infoPlistContent = """<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>CFBundleExecutable</key>
-  <string>$1</string>
-  <key>CFBundleIdentifier</key>
-  <string>com.nim.$1</string>
-  <key>CFBundleName</key>
-  <string>$1</string>
-  <key>CFBundlePackageType</key>
-  <string>APPL</string>
-  <key>LSUIElement</key>
-  <string>1</string>
-</dict>
-</plist>""" % [escapedName]
-
-  writeFile(infoPlistPath, infoPlistContent)
-
-  removeFile(exefile.string)
-
-  rawMessage(conf, hintUserRaw, "Created Mac app bundle: " & appBundlePath)
-
 proc getExtraCmds(conf: ConfigRef; output: AbsoluteFile): seq[string] =
   result = @[]
   when defined(macosx):
@@ -1047,10 +989,6 @@ proc callCCompiler*(conf: ConfigRef) =
         preventLinkCmdMaxCmdLen(conf, linkCmd)
         for cmd in extraCmds:
           execExternalProgram(conf, cmd, hintExecuting)
-        # create Mac app bundle for GUI apps on macOS
-        when defined(macosx):
-          if conf.globalOptions * {optGenGuiApp, optGenDynLib, optGenStaticLib} == {optGenGuiApp}:
-            createMacAppBundle(conf, mainOutput)
   else:
     linkCmd = ""
   if optGenScript in conf.globalOptions:

compiler/guards.nim

@@ -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)
@@ -1170,7 +1170,7 @@ proc buildProperFieldCheck(access, check: PNode; o: Operators): PNode =
       # set field name to discriminator field name
       a[1] = check[2]
       # set discriminator field type: important for `neg`
-      a.typ = check[2].typ
+      a.typ() = check[2].typ
       result[2] = a
       # 'access.kind != nkDotExpr' can happen for object constructors
       # which we don't check yet

compiler/hlo.nim

@@ -10,7 +10,7 @@
 # This include implements the high level optimization pass.
 # included from sem.nim
 
-proc hlo(c: PContext, n: PNode, loopDetector: int): PNode
+proc hlo(c: PContext, n: PNode): PNode
 
 proc evalPattern(c: PContext, n, orig: PNode): PNode =
   internalAssert c.config, n.kind == nkCall and n[0].kind == nkSym
@@ -61,11 +61,10 @@ proc applyPatterns(c: PContext, n: PNode): PNode =
         # activate this pattern again:
         c.patterns[i] = pattern
 
-proc hlo(c: PContext, n: PNode, loopDetector: int): PNode =
+proc hlo(c: PContext, n: PNode): PNode =
+  inc(c.hloLoopDetector)
   # simply stop and do not perform any further transformations:
-  if loopDetector > 300:
-    message(c.config, n.info, warnUser, "term rewrite macro instantiation too nested")
-    return n
+  if c.hloLoopDetector > 300: return n
   case n.kind
   of nkMacroDef, nkTemplateDef, procDefs:
     # already processed (special cases in semstmts.nim)
@@ -81,7 +80,7 @@ proc hlo(c: PContext, n: PNode, loopDetector: int): PNode =
       # no optimization applied, try subtrees:
       for i in 0..<result.safeLen:
         let a = result[i]
-        let h = hlo(c, a, loopDetector)
+        let h = hlo(c, a)
         if h != a: result[i] = h
     else:
       # perform type checking, so that the replacement still fits:
@@ -91,15 +90,17 @@ proc hlo(c: PContext, n: PNode, loopDetector: int): PNode =
         result = fitNode(c, n.typ, result, n.info)
       # optimization has been applied so check again:
       result = commonOptimizations(c.graph, c.idgen, c.module, result)
-      result = hlo(c, result, loopDetector + 1)
+      result = hlo(c, result)
       result = commonOptimizations(c.graph, c.idgen, c.module, result)
 
 proc hloBody(c: PContext, n: PNode): PNode =
   # fast exit:
   if c.patterns.len == 0 or optTrMacros notin c.config.options: return n
-  result = hlo(c, n, 0)
+  c.hloLoopDetector = 0
+  result = hlo(c, n)
 
 proc hloStmt(c: PContext, n: PNode): PNode =
   # fast exit:
   if c.patterns.len == 0 or optTrMacros notin c.config.options: return n
-  result = hlo(c, n, 0)
+  c.hloLoopDetector = 0
+  result = hlo(c, n)

compiler/ic/cbackend.nim

@@ -52,7 +52,7 @@ proc generateCodeForModule(g: ModuleGraph; m: var LoadedModule; alive: var Alive
 
   finalCodegenActions(g, bmod, newNodeI(nkStmtList, m.module.info))
   for disp in getDispatchers(g):
-    genProcLvl3(bmod, disp)
+    genProcAux(bmod, disp)
   m.fromDisk.backendFlags = cgen.whichInitProcs(bmod)
 
 proc replayTypeInfo(g: ModuleGraph; m: var LoadedModule; origin: FileIndex) =

compiler/ic/ic.nim

@@ -838,7 +838,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
   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
+      result.typ() = result.sym.typ
   of externIntLit:
     result.intVal = g[thisModule].fromDisk.numbers[n.litId]
   of nkStrLit..nkTripleStrLit:
@@ -852,7 +852,7 @@ proc loadNodes*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
     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
+      result.typ() = result.sym.typ
   else:
     for n0 in sonsReadonly(tree, n):
       result.addAllowNil loadNodes(c, g, thisModule, tree, n0)
@@ -899,11 +899,11 @@ proc moduleIndex*(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: in
 proc symHeaderFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
                          s: PackedSym; si, item: int32): PSym =
   result = PSym(itemId: ItemId(module: si, item: item),
-    kindImpl: s.kind, magicImpl: s.magic, flagsImpl: s.flags,
-    infoImpl: translateLineInfo(c, g, si, s.info),
-    optionsImpl: s.options,
-    positionImpl: if s.kind in {skForVar, skVar, skLet, skTemp}: 0 else: s.position,
-    offsetImpl: if s.kind in routineKinds: defaultOffset else: s.offset,
+    kind: s.kind, magic: s.magic, flags: s.flags,
+    info: translateLineInfo(c, g, si, s.info),
+    options: s.options,
+    position: if s.kind in {skForVar, skVar, skLet, skTemp}: 0 else: s.position,
+    offset: if s.kind in routineKinds: defaultOffset else: s.offset,
     disamb: s.disamb,
     name: getIdent(c.cache, g[si].fromDisk.strings[s.name])
   )
@@ -945,8 +945,8 @@ proc symBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
   setOwner(result, loadSym(c, g, si, s.owner))
   let externalName = g[si].fromDisk.strings[s.externalName]
   if externalName != "":
-    result.locImpl.snippet = externalName
-  result.locImpl.flags = s.locFlags
+    result.loc.snippet = externalName
+  result.loc.flags = s.locFlags
   result.instantiatedFrom = loadSym(c, g, si, s.instantiatedFrom)
 
 proc needsRecompile(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;
@@ -990,10 +990,10 @@ proc loadSym(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; s:
 proc typeHeaderFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
                           t: PackedType; si, item: int32): PType =
   result = PType(itemId: ItemId(module: si, item: t.nonUniqueId), kind: t.kind,
-                flagsImpl: t.flags, sizeImpl: t.size, alignImpl: t.align,
-                paddingAtEndImpl: t.paddingAtEnd,
+                flags: t.flags, size: t.size, align: t.align,
+                paddingAtEnd: t.paddingAtEnd,
                 uniqueId: ItemId(module: si, item: item),
-                callConvImpl: t.callConv)
+                callConv: t.callConv)
 
 proc typeBodyFromPacked(c: var PackedDecoder; g: var PackedModuleGraph;
                         t: PackedType; si, item: int32; result: PType) =
@@ -1058,12 +1058,12 @@ proc setupLookupTables(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCa
   let filename = AbsoluteFile toFullPath(conf, fileIdx)
   # We cannot call ``newSym`` here, because we have to circumvent the ID
   # mechanism, which we do in order to assign each module a persistent ID.
-  m.module = PSym(kindImpl: skModule, itemId: ItemId(module: int32(fileIdx), item: 0'i32),
+  m.module = PSym(kind: skModule, itemId: ItemId(module: int32(fileIdx), item: 0'i32),
                   name: getIdent(cache, splitFile(filename).name),
-                  infoImpl: newLineInfo(fileIdx, 1, 1),
-                  positionImpl: int(fileIdx))
+                  info: newLineInfo(fileIdx, 1, 1),
+                  position: int(fileIdx))
   setOwner(m.module, getPackage(conf, cache, fileIdx))
-  m.module.flagsImpl = m.fromDisk.moduleFlags
+  m.module.flags = m.fromDisk.moduleFlags
 
 proc loadToReplayNodes(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache;
                        fileIdx: FileIndex; m: var LoadedModule) =

compiler/importer.nim

@@ -231,7 +231,7 @@ proc importForwarded(c: PContext, n: PNode, exceptSet: IntSet; fromMod: PSym; im
     for i in 0..n.safeLen-1:
       importForwarded(c, n[i], exceptSet, fromMod, importSet)
 
-proc importModuleAs(c: PContext; n: PNode, realModule: PSym, importHidden, trackUnusedImport: bool): PSym =
+proc importModuleAs(c: PContext; n: PNode, realModule: PSym, importHidden: bool): PSym =
   result = realModule
   template createModuleAliasImpl(ident): untyped =
     createModuleAlias(realModule, c.idgen, ident, n.info, c.config.options)
@@ -245,12 +245,9 @@ proc importModuleAs(c: PContext; n: PNode, realModule: PSym, importHidden, track
     # avoids modifying `realModule`, see D20201209T194412 for `import {.all.}`
     result = createModuleAliasImpl(realModule.name)
   if importHidden:
-    ensureMutable result
-    result.optionsImpl.incl optImportHidden
-  let moduleIdent = if n.kind in {nkInfix, nkImportAs}: n[^1] else: n
-  result.info = moduleIdent.info
-  if trackUnusedImport:
-    c.unusedImports.add((result, result.info))
+    result.options.incl optImportHidden
+  let moduleIdent = if n.kind == nkInfix: n[^1] else: n
+  c.unusedImports.add((result, moduleIdent.info))
   c.importModuleMap[result.id] = realModule.id
   c.importModuleLookup.mgetOrPut(result.name.id, @[]).addUnique realModule.id
 
@@ -291,11 +288,10 @@ proc myImportModule(c: PContext, n: var PNode, importStmtResult: PNode): PSym =
                 toFullPath(c.config, c.graph.importStack[i+1])
       c.recursiveDep = err
 
-    let trackUnusedImport = warnUnusedImportX in c.config.notes
     var realModule: PSym
     discard pushOptionEntry(c)
     realModule = c.graph.importModuleCallback(c.graph, c.module, f)
-    result = importModuleAs(c, n, realModule, transf.importHidden, trackUnusedImport)
+    result = importModuleAs(c, n, realModule, transf.importHidden)
     popOptionEntry(c)
 
     #echo "set back to ", L
@@ -339,7 +335,7 @@ proc impMod(c: PContext; it: PNode; importStmtResult: PNode) =
   let m = myImportModule(c, it, importStmtResult)
   if m != nil:
     # ``addDecl`` needs to be done before ``importAllSymbols``!
-    addDecl(c, m) # add symbol to symbol table of module
+    addDecl(c, m, it.info) # add symbol to symbol table of module
     importAllSymbols(c, m)
     #importForwarded(c, m.ast, emptySet, m)
     afterImport(c, m)
@@ -376,7 +372,7 @@ proc evalFrom*(c: PContext, n: PNode): PNode =
   var m = myImportModule(c, n[0], result)
   if m != nil:
     n[0] = newSymNode(m)
-    addDecl(c, m)               # add symbol to symbol table of module
+    addDecl(c, m, n.info)               # add symbol to symbol table of module
 
     var im = ImportedModule(m: m, mode: importSet, imported: initIntSet())
     for i in 1..<n.len:
@@ -391,7 +387,7 @@ proc evalImportExcept*(c: PContext, n: PNode): PNode =
   var m = myImportModule(c, n[0], result)
   if m != nil:
     n[0] = newSymNode(m)
-    addDecl(c, m)               # add symbol to symbol table of module
+    addDecl(c, m, n.info)               # add symbol to symbol table of module
     importAllSymbolsExcept(c, m, readExceptSet(c, n))
     #importForwarded(c, m.ast, exceptSet, m)
     afterImport(c, m)

compiler/injectdestructors.nim

@@ -24,7 +24,7 @@ import std/[strtabs, tables, strutils, intsets]
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
-from trees import exprStructuralEquivalent, getRoot, whichPragma, getPotentialWrites
+from trees import exprStructuralEquivalent, getRoot, whichPragma
 
 type
   Con = object
@@ -100,7 +100,6 @@ when false:
 proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
   let root = parampatterns.exprRoot(n, allowCalls=false)
   if root == nil: return false
-  elif sfSingleUsedTemp in root.flags: return true
 
   var s = addr(scope)
   while s != nil:
@@ -163,16 +162,13 @@ proc isLastReadImpl(n: PNode; c: var Con; scope: var Scope): bool =
   else:
     result = false
 
-template hasDestructorOrAsgn(c: var Con, typ: PType): bool =
-  # bug #23354; an object type could have a non-trivial assignements when it is passed to a sink parameter
-  hasDestructor(c, typ) or (c.graph.config.selectedGC in {gcArc, gcOrc, gcAtomicArc} and
-        typ.kind == tyObject and not isTrivial(getAttachedOp(c.graph, typ, attachedAsgn)))
-
 proc isLastRead(n: PNode; c: var Con; s: var Scope): bool =
-  if not hasDestructorOrAsgn(c, n.typ): return true
+  # 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
 
   let m = skipConvDfa(n)
-  result = isLastReadImpl(n, c, s)
+  result = (m.kind == nkSym and sfSingleUsedTemp in m.sym.flags) or
+      isLastReadImpl(n, c, s)
 
 proc isFirstWrite(n: PNode; c: var Con): bool =
   let m = skipConvDfa(n)
@@ -189,11 +185,10 @@ proc isCursor(n: PNode): bool =
   else:
     false
 
-template isFullyUnpackedTuple(n: PNode): bool =
+template isUnpackedTuple(n: PNode): bool =
   ## we move out all elements of unpacked tuples,
   ## hence unpacked tuples themselves don't need to be destroyed
   ## except it's already a cursor
-  ## restricted to `skTemp`, tuple temps where not every field is unpacked should not use `skTemp`
   (n.kind == nkSym and n.sym.kind == skTemp and
    n.sym.typ.kind == tyTuple and sfCursor notin n.sym.flags)
 
@@ -202,8 +197,7 @@ proc checkForErrorPragma(c: Con; t: PType; ri: PNode; opname: string; inferredFr
   if inferredFromCopy:
     m.add ", which is inferred from unavailable '=copy'"
 
-  if (opname == "=" or opname == "=copy" or opname == "=dup") and
-       ri != nil:
+  if (opname == "=" or opname == "=copy" or opname == "=dup") and ri != nil:
     m.add "; requires a copy because it's not the last read of '"
     m.add renderTree(ri)
     m.add '\''
@@ -253,12 +247,7 @@ proc genOp(c: var Con; t: PType; kind: TTypeAttachedOp; dest, ri: PNode): PNode
   dbg:
     if kind == attachedDestructor:
       echo "destructor is ", op.id, " ", op.ast
-  if sfError in op.flags:
-    if ri != nil:
-      checkForErrorPragma(c, t, ri, AttachedOpToStr[kind])
-    else:
-      # uses the lineinfos of `dest` is `ri` is not available
-      checkForErrorPragma(c, t, dest, AttachedOpToStr[kind])
+  if sfError in op.flags: checkForErrorPragma(c, t, ri, AttachedOpToStr[kind])
   c.genOp(op, dest)
 
 proc genDestroy(c: var Con; dest: PNode): PNode =
@@ -286,7 +275,7 @@ proc deepAliases(dest, ri: PNode): bool =
     return aliases(dest, ri) != no
 
 proc genSink(c: var Con; s: var Scope; dest, ri: PNode; flags: set[MoveOrCopyFlag] = {}): PNode =
-  if (c.inLoopCond == 0 and (isFullyUnpackedTuple(dest) or IsDecl in flags or
+  if (c.inLoopCond == 0 and (isUnpackedTuple(dest) or IsDecl in flags or
       (isAnalysableFieldAccess(dest, c.owner) and isFirstWrite(dest, c)))) or
       isNoInit(dest) or IsReturn in flags:
     # optimize sink call into a bitwise memcopy
@@ -343,7 +332,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 =
@@ -411,7 +400,7 @@ proc genWasMoved(c: var Con, n: PNode): PNode =
     result = genOp(c, op, n)
   else:
     result = newNodeI(nkCall, n.info)
-    result.add(newSymNode(createMagic(c.graph, c.idgen, "wasMoved", mWasMoved)))
+    result.add(newSymNode(createMagic(c.graph, c.idgen, "`=wasMoved`", mWasMoved)))
     result.add copyTree(n) #mWasMoved does not take the address
     #if n.kind != nkSym:
     #  message(c.graph.config, n.info, warnUser, "wasMoved(" & $n & ")")
@@ -419,7 +408,7 @@ 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)
@@ -460,7 +449,7 @@ 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 hasDestructorOrAsgn(c, nTyp):
+  if hasDestructor(c, nTyp):
     let typ = nTyp.skipTypes({tyGenericInst, tyAlias, tySink})
     let op = getAttachedOp(c.graph, typ, attachedDup)
     if op != nil and tfHasOwned notin typ.flags:
@@ -570,7 +559,7 @@ proc cycleCheck(n: PNode; c: var Con) =
 proc pVarTopLevel(v: PNode; c: var Con; s: var Scope; res: PNode) =
   # move the variable declaration to the top of the frame:
   s.vars.add v.sym
-  if isFullyUnpackedTuple(v):
+  if isUnpackedTuple(v):
     if c.inLoop > 0:
       # unpacked tuple needs reset at every loop iteration
       res.add newTree(nkFastAsgn, v, genDefaultCall(v.typ, c, v.info))
@@ -813,7 +802,15 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       result = passCopyToSink(n, c, s)
     elif n.kind in {nkBracket, nkObjConstr, nkTupleConstr, nkClosure, nkNilLit} +
          nkCallKinds + nkLiterals:
-      result = p(n, c, s, consumed)
+      if n.kind in nkCallKinds and n[0].kind == nkSym:
+        if n[0].sym.magic == mEnsureMove:
+          inc c.inEnsureMove
+          result = p(n[1], c, s, sinkArg)
+          dec c.inEnsureMove
+        else:
+          result = p(n, c, s, consumed)
+      else:
+        result = p(n, c, s, consumed)
     elif ((n.kind == nkSym and isSinkParam(n.sym)) or isAnalysableFieldAccess(n, c.owner)) and
         isLastRead(n, c, s) and not (n.kind == nkSym and isCursor(n)):
       # Sinked params can be consumed only once. We need to reset the memory
@@ -825,9 +822,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, sinkArg)
-        result[1].typ = nTyp
+        result[1].typ() = nTyp
       else:
         result[1] = p(n[1], c, s, sinkArg)
     elif n.kind in {nkObjDownConv, nkObjUpConv}:
@@ -889,6 +886,12 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
       if mode == normal and (isRefConstr or hasCustomDestructor(c, t)):
         result = ensureDestruction(result, n, c, s)
     of nkCallKinds:
+      if n[0].kind == nkSym and n[0].sym.magic == mEnsureMove:
+        inc c.inEnsureMove
+        result = p(n[1], c, s, sinkArg)
+        dec c.inEnsureMove
+        return
+
       let inSpawn = c.inSpawn
       if n[0].kind == nkSym and n[0].sym.magic == mSpawn:
         c.inSpawn.inc
@@ -906,19 +909,13 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
           isDangerous = true
 
       result = shallowCopy(n)
-
-      if n[0].kind == nkSym and n[0].sym.magic == mEnsureMove:
-        inc c.inEnsureMove
-        result[1] = p(n[1], c, s, sinkArg)
-        dec c.inEnsureMove
-      else:
-        for i in 1..<n.len:
-          if i < L and isCompileTimeOnly(parameters[i]):
-            result[i] = n[i]
-          elif i < L and (isSinkTypeForParam(parameters[i]) or inSpawn > 0):
-            result[i] = p(n[i], c, s, sinkArg)
-          else:
-            result[i] = p(n[i], c, s, normal)
+      for i in 1..<n.len:
+        if i < L and isCompileTimeOnly(parameters[i]):
+          result[i] = n[i]
+        elif i < L and (isSinkTypeForParam(parameters[i]) or inSpawn > 0):
+          result[i] = p(n[i], c, s, sinkArg)
+        else:
+          result[i] = p(n[i], c, s, normal)
 
       when false:
         if isDangerous:
@@ -946,9 +943,6 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
     of nkVarSection, nkLetSection:
       # transform; var x = y to  var x; x op y  where op is a move or copy
       result = newNodeI(nkStmtList, n.info)
-
-      let isInProc = c.owner.kind in {skProc, skFunc, skMethod, skIterator, skConverter}
-
       for it in n:
         var ri = it[^1]
         if it.kind == nkVarTuple and hasDestructor(c, ri.typ):
@@ -964,15 +958,7 @@ proc p(n: PNode; c: var Con; s: var Scope; mode: ProcessMode; tmpFlags = {sfSing
               s.locals.add v.sym
               pVarTopLevel(v, c, s, result)
             if ri.kind != nkEmpty:
-              let isGlobalPragma = v.kind == nkSym and
-                      {sfPure, sfGlobal} <= v.sym.flags and
-                      isInProc
-
-              if isGlobalPragma:
-                c.graph.procGlobals.add n
-              else:
-                let value = moveOrCopy(v, ri, c, s, if v.kind == nkSym: {IsDecl} else: {})
-                result.add value
+              result.add moveOrCopy(v, ri, c, s, if v.kind == nkSym: {IsDecl} else: {})
             elif ri.kind == nkEmpty and c.inLoop > 0:
               let skipInit = v.kind == nkDotExpr and # Closure var
                              sfNoInit in v[1].sym.flags
@@ -1036,9 +1022,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)
 
@@ -1144,25 +1130,6 @@ proc genFieldAccessSideEffects(c: var Con; s: var Scope; dest, ri: PNode; flags:
   var snk = c.genSink(s, dest, newAccess, flags)
   result = newTree(nkStmtList, v, snk, c.genWasMoved(newAccess))
 
-proc ownsData(c: var Con; s: var Scope; orig: PNode; flags: set[MoveOrCopyFlag]): PNode =
-  var n = orig
-  while true:
-    case n.kind
-    of nkDotExpr, nkCheckedFieldExpr, nkBracketExpr:
-      n = n[0]
-    else:
-      break
-  if n.kind in nkCallKinds and n.typ != nil and hasDestructor(c, n.typ):
-    result = newNodeIT(nkStmtListExpr, orig.info, orig.typ)
-    let tmp = c.getTemp(s, n.typ, n.info)
-    tmp.sym.flagsImpl.incl sfSingleUsedTemp
-    result.add newTree(nkFastAsgn, tmp, copyTree(n))
-    s.final.add c.genDestroy(tmp)
-    n[] = tmp[]
-    result.add copyTree(orig)
-  else:
-    result = nil
-
 proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopyFlag] = {}): PNode =
   var ri = ri
   var isEnsureMove = 0
@@ -1189,7 +1156,7 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
     of nkCallKinds:
       result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
     of nkBracketExpr:
-      if isFullyUnpackedTuple(ri[0]):
+      if isUnpackedTuple(ri[0]):
         # unpacking of tuple: take over the elements
         result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
       elif isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s):
@@ -1238,22 +1205,15 @@ proc moveOrCopy(dest, ri: PNode; c: var Con; s: var Scope, flags: set[MoveOrCopy
         result.add p(ri, c, s, consumed)
         c.finishCopy(result, dest, flags, isFromSink = false)
     of nkHiddenSubConv, nkHiddenStdConv, nkConv, nkObjDownConv, nkObjUpConv, nkCast:
-      if IsExplicitSink in flags:
-        result = c.genSink(s, dest, p(ri, c, s, consumed), flags)
-      else:
-        result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
-    of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt, nkPragmaBlock:
+      result = c.genSink(s, dest, p(ri, c, s, sinkArg), flags)
+    of nkStmtListExpr, nkBlockExpr, nkIfExpr, nkCaseStmt, nkTryStmt:
       template process(child, s): untyped = moveOrCopy(dest, child, c, s, flags)
       # We know the result will be a stmt so we use that fact to optimize
       handleNestedTempl(ri, process, willProduceStmt = true)
     of nkRaiseStmt:
       result = pRaiseStmt(ri, c, s)
     else:
-      let isOwnsData = ownsData(c, s, ri2, flags)
-
-      if isOwnsData != nil:
-        result = moveOrCopy(dest, isOwnsData, c, s, flags)
-      elif isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s) and
+      if isAnalysableFieldAccess(ri, c.owner) and isLastRead(ri, c, s) and
           canBeMoved(c, dest.typ):
         # Rule 3: `=sink`(x, z); wasMoved(z)
         let snk = c.genSink(s, dest, ri, flags)
@@ -1292,55 +1252,6 @@ when false:
       for i in 0..<n.safeLen:
         injectDefaultCalls(n[i], c)
 
-proc replaceSinkParam(n: PNode, mapping: Table[int, PSym]): PNode =
-  case n.kind
-  of nkSym:
-    if n.sym.id in mapping:
-      result = newSymNode(mapping[n.sym.id])
-    else:
-      result = n
-  of nkVarSection, nkLetSection:
-    result = copyNode(n)
-    newSons(result, n.len)
-    for i in 0..<n.len:
-      result[i] = copyNode(n[i])
-      for j in 0..<n[i].len-1:
-        result[i].add n[i][j]
-      result[i].add replaceSinkParam(n[i][^1], mapping)
-  of {nkNone..nkNilLit}-{nkSym}, nkTypeSection, nkProcDef, nkConverterDef,
-      nkMethodDef, nkIteratorDef, nkMacroDef, nkTemplateDef, nkLambda, nkDo,
-      nkFuncDef, nkConstSection, nkConstDef, nkIncludeStmt, nkImportStmt,
-      nkExportStmt, nkPragma, nkCommentStmt, nkBreakState,
-      nkTypeOfExpr, nkMixinStmt, nkBindStmt:
-    result = n
-  else:
-    result = copyNode(n)
-    for i in 0..<n.len:
-      result.add replaceSinkParam(n[i], mapping)
-
-proc addSinkCopy(c: var Con; s: var Scope; sinkParams: seq[PSym]; n: PNode): PNode =
-  result = newNodeI(nkStmtList, n.info)
-  var mapping = initTable[int, PSym]()
-
-  var mutated = newSeq[PNode]()
-  getPotentialWrites(n, false, mutated)
-  var mutatedSet = initIntSet()
-  for m in mutated:
-    mutatedSet.incl m.sym.id
-  for param in sinkParams:
-    if param.id in mutatedSet:
-      let newSym = newSym(skTemp, getIdent(c.graph.cache, "sinkCopy"), c.idgen, param.owner, n.info)
-      newSym.flagsImpl.incl sfFromGeneric
-      newSym.typ = param.typ.elementType
-      mapping[param.id] = newSym
-      let v = newNodeI(nkVarSection, n.info)
-      v.addVar(newSymNode(newSym), newSymNode(param))
-      result.add v
-  if mapping.len > 0:
-    result.add replaceSinkParam(n, mapping)
-  else:
-    result = n
-
 proc injectDestructorCalls*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n: PNode): PNode =
   when toDebug.len > 0:
     shouldDebug = toDebug == owner.name.s or toDebug == "always"
@@ -1354,24 +1265,15 @@ proc injectDestructorCalls*(g: ModuleGraph; idgen: IdGenerator; owner: PSym; n:
   var scope = Scope(body: n)
   let body = p(n, c, scope, normal)
 
-  var sinkParams = newSeq[PSym]()
-
   if owner.kind in {skProc, skFunc, skMethod, skIterator, skConverter}:
     let params = owner.typ.n
     for i in 1..<params.len:
       let t = params[i].sym.typ
-      if isSinkTypeForParam(t):
-        let baseType = t.skipTypes({tySink})
-        if baseType.kind in {tyString, tySequence, tyArray, tyTuple, tyObject}:
-          sinkParams.add params[i].sym
-        if hasDestructor(c, baseType):
-          scope.final.add c.genDestroy(params[i])
+      if isSinkTypeForParam(t) and hasDestructor(c, t.skipTypes({tySink})):
+        scope.final.add c.genDestroy(params[i])
   #if optNimV2 in c.graph.config.globalOptions:
   #  injectDefaultCalls(n, c)
   result = optimize processScope(c, scope, body)
-  if sinkParams.len > 0:
-    result = addSinkCopy(c, scope, sinkParams, result)
-
   dbg:
     echo ">---------transformed-to--------->"
     echo renderTree(result, {renderIds})

compiler/inliner.nim

@@ -1,122 +0,0 @@
-
-proc copySymdef(n: PNode; locals: var Table[int, PSym]; idgen: IdGenerator; owner: PSym): PNode =
-  case n.kind
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit:
-    result = n
-  of nkSym:
-    let oldSym = n.sym
-    let newSym = copySym(oldSym, idgen)
-    setOwner(newSym, owner)
-    locals[oldSym.id] = newSym
-    result = newSymNode(newSym, oldSym.info)
-  else:
-    result = shallowCopy(n)
-    for i in 0..<n.len:
-      result[i] = copySymdef(n[i], locals, idgen, owner)
-
-proc copyInlineProcBody(n: PNode; locals: var Table[int, PSym]; idgen: IdGenerator; owner: PSym): PNode =
-  case n.kind
-  of nkEmpty..pred(nkSym), succ(nkSym)..nkNilLit:
-    result = n
-  of nkSym:
-    let sym = locals.getOrDefault(n.sym.id)
-    if sym != nil:
-      result = newSymNode(sym, n.info)
-    else:
-      result = n
-  of nkLetSection, nkVarSection:
-    result = shallowCopy(n)
-    for i in 0..<n.len:
-      let it = n[i]
-      if it.kind == nkCommentStmt:
-        result[i] = it
-      elif it.kind in {nkIdentDefs, nkConstDef}:
-        result[i] = shallowCopy(it)
-        for j in 0..<it.len-2:
-          result[i][j] = copySymdef(it[j], locals, idgen, owner)
-        for j in it.len-2..<it.len:
-          result[i][j] = copyInlineProcBody(it[j], locals, idgen, owner)
-      else:
-        assert it.kind == nkVarTuple
-        result[i] = shallowCopy(it)
-        for j in 0..<it.len-2:
-          assert it[j].kind == nkSym
-          let oldSym = it[j].sym
-          let newSym = copySym(oldSym, idgen)
-          setOwner(newSym, owner)
-          locals[oldSym.id] = newSym
-          result[i][j] = newSymNode(newSym, oldSym.info)
-        for j in it.len-2..<it.len:
-          result[i][j] = copyInlineProcBody(it[j], locals, idgen, owner)
-
-  of nkForStmt, nkParForStmt:
-    result = shallowCopy(n)
-    for i in 0..<n.len-2:
-      assert n[i].kind == nkSym
-      let oldSym = n[i].sym
-      let newSym = copySym(oldSym, idgen)
-      setOwner(newSym, owner)
-      locals[oldSym.id] = newSym
-      result[i] = newSymNode(newSym, oldSym.info)
-    result[n.len-2] = copyInlineProcBody(n[n.len-2], locals, idgen, owner)
-    result[n.len-1] = copyInlineProcBody(n[n.len-1], locals, idgen, owner)
-  of routineDefs, nkTypeSection, nkTypeOfExpr, nkMixinStmt, nkBindStmt, nkConstSection:
-    result = n
-  else:
-    result = shallowCopy(n)
-    for i in 0..<n.len:
-      result[i] = copyInlineProcBody(n[i], locals, idgen, owner)
-
-proc copyParams(n: PNode; locals: var Table[int, PSym]; idgen: IdGenerator; owner: PSym): PNode =
-  result = shallowCopy(n)
-  result[0] = n[0] # return type
-  for i in 1..<n.len:
-    let it = n[i]
-    assert it.kind == nkIdentDefs
-    result[i] = shallowCopy(it)
-    for j in 0..<it.len-2:
-      assert it[j].kind == nkSym
-      let oldSym = it[j].sym
-      let newSym = copySym(oldSym, idgen)
-      setOwner(newSym, owner)
-      locals[oldSym.id] = newSym
-      result[i][j] = newSymNode(newSym, oldSym.info)
-      owner.typ.addParam newSym
-    for j in it.len-2..<it.len:
-      result[i][j] = copyInlineProcBody(it[j], locals, idgen, owner)
-
-proc copyInlineProc(prc: PSym; idgen: IdGenerator): PSym =
-  result = copySym(prc, idgen)
-  var locals = initTable[int, PSym]()
-
-  var a = shallowCopy(prc.ast)
-  if resultPos < prc.ast.len and prc.ast[resultPos].kind == nkSym:
-    let oldRes = prc.ast[resultPos].sym
-    let newRes = copySym(oldRes, idgen)
-    setOwner(newRes, result)
-    locals[oldRes.id] = newRes
-    a[resultPos] = newSymNode(newRes, oldRes.info)
-
-  result.typ = copyType(prc.typ, idgen, result)
-  result.typ.n = newNodeI(prc.typ.n.kind, prc.typ.n.info)
-  if prc.typ.n.len > 0:
-    result.typ.n.add copyNode(prc.typ.n[0])
-    for i in 1..<prc.typ.n.len:
-      let it = prc.typ.n[i]
-      assert it.kind == nkSym
-      let oldSym = it.sym
-      let newSym = copySym(oldSym, idgen)
-      setOwner(newSym, result)
-      locals[oldSym.id] = newSym
-      result.typ.addParam newSym
-
-  for i in 0..<prc.ast.len:
-    if i == paramsPos:
-      a[i] = copyTree(prc.ast[i])
-    elif i == resultPos and prc.ast[i].kind == nkSym:
-      discard "handled above"
-    else:
-      a[i] = copyInlineProcBody(prc.ast[i], locals, idgen, result)
-  result.ast = a
-
-  #echo "Produced: ", renderTree(result.ast, {renderIds})

compiler/installer.ini

@@ -6,7 +6,7 @@ Name: "Nim"
 Version: "$version"
 Platforms: """
   windows: i386;amd64
-  linux: i386;hppa;ia64;alpha;amd64;powerpc64;arm;sparc;sparc64;s390x;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;loongarch64
   macosx: i386;amd64;powerpc64;arm64
   solaris: i386;amd64;sparc;sparc64
   freebsd: i386;amd64;powerpc64;arm;arm64;riscv64;sparc64;mips;mipsel;mips64;mips64el;powerpc;powerpc64el
@@ -80,7 +80,6 @@ Files: "lib"
 Files: "examples"
 Files: "dist/nimble"
 Files: "dist/checksums"
-Files: "dist/nimony"
 
 Files: "tests"
 

compiler/isolation_check.nim

@@ -166,7 +166,7 @@ proc containsVariable(n: PNode): bool =
 proc checkIsolate*(n: PNode): bool =
   if types.containsTyRef(n.typ):
     # XXX Maybe require that 'n.typ' is acyclic. This is not much
-    # worse than the already existing inheritance and closure restrictions.
+    # worse than the already exisiting inheritance and closure restrictions.
     case n.kind
     of nkCharLit..nkNilLit:
       result = true

compiler/jsgen.nim

@@ -277,8 +277,7 @@ proc mangleName(m: BModule, s: PSym): Rope =
       else:
         result.add("_")
         result.add(rope(s.id))
-    ensureMutable s
-    s.locImpl.snippet = result
+    s.loc.snippet = result
 
 proc escapeJSString(s: string): string =
   result = newStringOfCap(s.len + s.len shr 2)
@@ -1003,8 +1002,7 @@ 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:
-        ensureMutable excAlias.sym
-        excAlias.sym.locImpl.snippet = mangleName(p.module, excAlias.sym)
+        excAlias.sym.loc.snippet = mangleName(p.module, excAlias.sym)
         lineF(p, "var $1 = lastJSError;$n", excAlias.sym.loc.snippet)
       gen(p, n[i][^1], a)
       moveInto(p, a, r)
@@ -1137,8 +1135,7 @@ proc genBlock(p: PProc, n: PNode, r: var TCompRes) =
     # named block?
     if (n[0].kind != nkSym): internalError(p.config, n.info, "genBlock")
     var sym = n[0].sym
-    ensureMutable sym
-    sym.locImpl.k = locOther
+    sym.loc.k = locOther
     sym.position = idx+1
   let labl = p.unique
   lineF(p, "Label$1: {$n", [labl.rope])
@@ -1237,8 +1234,7 @@ proc generateHeader(p: PProc, prc: PSym): Rope =
       # to keep it simple
       let env = prc.ast[paramsPos].lastSon
       assert env.kind == nkSym, "env is missing"
-      ensureMutable env.sym
-      env.sym.locImpl.snippet = "this"
+      env.sym.loc.snippet = "this"
 
   for i in 1..<typ.n.len:
     assert(typ.n[i].kind == nkSym)
@@ -1375,15 +1371,12 @@ proc genFieldAddr(p: PProc, n: PNode, r: var TCompRes) =
   r.typ = etyBaseIndex
   let b = if n.kind == nkHiddenAddr: n[0] else: n
   gen(p, b[0], a)
-  if skipTypes(b[0].typ, abstractVarRange + tyTypeClasses).kind == tyTuple:
-    # ref #25227 about `+ tyTypeClasses`
+  if skipTypes(b[0].typ, abstractVarRange).kind == tyTuple:
     r.res = makeJSString("Field" & $getFieldPosition(p, b[1]))
   else:
     if b[1].kind != nkSym: internalError(p.config, b[1].info, "genFieldAddr")
     var f = b[1].sym
-    if f.loc.snippet == "": 
-      ensureMutable f
-      f.locImpl.snippet = mangleName(p.module, f)
+    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
     r.res = makeJSString($f.loc.snippet)
   internalAssert p.config, a.typ != etyBaseIndex
   r.address = a.res
@@ -1411,9 +1404,7 @@ 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 == "": 
-      ensureMutable f
-      f.locImpl.snippet = mangleName(p.module, f)
+    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
     r.res = "$1.$2" % [r.res, f.loc.snippet]
     mkTemp(1)
   r.kind = resExpr
@@ -1434,15 +1425,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 == "": 
-    ensureMutable field
-    field.locImpl.snippet = mangleName(p.module, field)
+  if field.loc.snippet == "": field.loc.snippet = mangleName(p.module, field)
   # Discriminant symbol
   let disc = checkExpr[2].sym
   internalAssert p.config, disc.kind == skField
-  if disc.loc.snippet == "": 
-    ensureMutable disc
-    disc.locImpl.snippet = mangleName(p.module, disc)
+  if disc.loc.snippet == "": disc.loc.snippet = mangleName(p.module, disc)
 
   var setx: TCompRes = default(TCompRes)
   gen(p, checkExpr[1], setx)
@@ -1598,12 +1585,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:
-      if n.kind in {nkAddr, nkHiddenAddr}:
-        # addr ( deref ( x )) --> x
-        gen(p, n[0][0], r)
-      else:
-        gen(p, n[0], r)
+    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:
@@ -1854,9 +1844,7 @@ 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 == "": 
-    ensureMutable f
-    f.locImpl.snippet = mangleName(p.module, f)
+  if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
   if sfInfixCall in f.flags:
     let pat = $n[0].sym.loc.snippet
     internalAssert p.config, pat.len > 0
@@ -2348,8 +2336,8 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
       r.res = "if (null != $1) { if (null == $2) $2 = $3; else $2 += $3; }" %
         [b, lhs.rdLoc, tmp]
     else:
-      useMagic(p, "nimAddStrStr")
-      r.res = "nimAddStrStr($1, $2);" % [lhs.rdLoc, rhs.rdLoc]
+      let (a, tmp) = maybeMakeTemp(p, n[1], lhs)
+      r.res = "$1.push.apply($3, $2);" % [a, rhs.rdLoc, tmp]
     r.kind = resExpr
   of mAppendSeqElem:
     var x, y: TCompRes = default(TCompRes)
@@ -2453,7 +2441,7 @@ proc genMagic(p: PProc, n: PNode, r: var TCompRes) =
     binaryExpr(p, n, r, "mnewString",
       """if ($1.length < $2) { for (var i = $3.length; i < $4; ++i) $3.push(0); }
          else {$3.length = $4; }""")
-  of mSetLengthSeq, mSetLengthSeqUninit:
+  of mSetLengthSeq:
     var x, y: TCompRes = default(TCompRes)
     gen(p, n[1], x)
     gen(p, n[2], y)
@@ -2592,9 +2580,7 @@ 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 == "": 
-      ensureMutable f
-      f.locImpl.snippet = mangleName(p.module, f)
+    if f.loc.snippet == "": f.loc.snippet = mangleName(p.module, f)
     fieldIDs.incl(lookupFieldAgain(n.typ.skipTypes({tyDistinct}), f).id)
 
     let typ = val.typ.skipTypes(abstractInst)
@@ -2896,8 +2882,6 @@ proc genCast(p: PProc, n: PNode, r: var TCompRes) =
   elif dest.kind in tyFloat..tyFloat64:
     if src.kind in {tyInt64, tyUInt64} and optJsBigInt64 in p.config.globalOptions:
       r.res = "Number($1)" % [r.res]
-  elif dest.kind == tyChar and (fromInt or fromUint):
-    r.res = "($1 & 255)" % [r.res]
   elif (src.kind == tyPtr and mapType(p, src) == etyObject) and dest.kind == tyPointer:
     r.address = r.res
     r.res = "null"

compiler/jstypes.nim

@@ -122,7 +122,7 @@ proc genEnumInfo(p: PProc, typ: PType, name: Rope) =
          [name, genTypeInfo(p, typ.baseClass)])
 
 proc genTypeInfo(p: PProc, typ: PType): Rope =
-  let t = typ.skipTypes({tyGenericInst, tyDistinct, tyAlias, tySink, tyOwned} + tyUserTypeClasses)
+  let t = typ.skipTypes({tyGenericInst, tyDistinct, tyAlias, tySink, tyOwned})
   result = "NTI$1" % [rope(t.id)]
   if containsOrIncl(p.g.typeInfoGenerated, t.id): return
   case t.kind

compiler/lambdalifting.nim

@@ -150,7 +150,6 @@ template isIterator*(owner: PSym): bool =
 
 proc createEnvObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo): PType =
   result = createObj(g, idgen, owner, info, final=false)
-  result.incl tfFinal
   if owner.isIterator:
     rawAddField(result, createStateField(g, owner, idgen))
 
@@ -161,7 +160,7 @@ proc getClosureIterResult*(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym
     # XXX a bit hacky:
     result = newSym(skResult, getIdent(g.cache, ":result"), idgen, iter, iter.info, {})
     result.typ = iter.typ.returnType
-    incl(result.flagsImpl, sfUsed)
+    incl(result.flags, sfUsed)
     iter.ast.add newSymNode(result)
 
 proc addHiddenParam(routine: PSym, param: PSym) =
@@ -200,7 +199,7 @@ proc interestingVar(s: PSym): bool {.inline.} =
 proc illegalCapture(s: PSym): bool {.inline.} =
   result = classifyViewType(s.typ) != noView or s.kind == skResult
 
-proc isInnerProc*(s: PSym): bool =
+proc isInnerProc(s: PSym): bool =
   if s.kind in {skProc, skFunc, skMethod, skConverter, skIterator} and s.magic == mNone:
     result = s.skipGenericOwner.kind in routineKinds
   else:
@@ -228,7 +227,7 @@ proc makeClosure*(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; inf
   #if isClosureIterator(result.typ):
   createTypeBoundOps(g, nil, result.typ, info, idgen)
   if tfHasAsgn in result.typ.flags or optSeqDestructors in g.config.globalOptions:
-    prc.incl sfInjectDestructors
+    prc.flags.incl sfInjectDestructors
 
 template liftingHarmful(conf: ConfigRef; owner: PSym): bool =
   ## lambda lifting can be harmful for JS-like code generators.
@@ -240,7 +239,7 @@ proc createTypeBoundOpsLL(g: ModuleGraph; refType: PType; info: TLineInfo; idgen
     createTypeBoundOps(g, nil, refType.elementType, info, idgen)
     createTypeBoundOps(g, nil, refType, info, idgen)
     if tfHasAsgn in refType.flags or optSeqDestructors in g.config.globalOptions:
-      owner.incl sfInjectDestructors
+      owner.flags.incl sfInjectDestructors
 
 proc genCreateEnv(env: PNode): PNode =
   var c = newNodeIT(nkObjConstr, env.info, env.typ)
@@ -290,7 +289,7 @@ proc markAsClosure(g: ModuleGraph; owner: PSym; n: PNode) =
   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])
-  incl(owner.typ, tfCapturesEnv)
+  incl(owner.typ.flags, tfCapturesEnv)
   if not isEnv:
     owner.typ.callConv = ccClosure
 
@@ -336,7 +335,7 @@ proc asOwnedRef(c: var DetectionPass; t: PType): PType =
   if optOwnedRefs in c.graph.config.globalOptions:
     assert t.kind == tyRef
     result = newType(tyOwned, c.idgen, t.owner)
-    result.incl tfHasOwned
+    result.flags.incl tfHasOwned
     result.rawAddSon t
   else:
     result = t
@@ -414,7 +413,7 @@ proc addClosureParam(c: var DetectionPass; fn: PSym; info: TLineInfo) =
   let t = c.getEnvTypeForOwner(owner, info)
   if cp == nil:
     cp = newSym(skParam, getIdent(c.graph.cache, paramName), c.idgen, fn, fn.info)
-    incl(cp.flagsImpl, sfFromGeneric)
+    incl(cp.flags, sfFromGeneric)
     cp.typ = t
     addHiddenParam(fn, cp)
   elif cp.typ != t and fn.kind != skIterator:
@@ -610,7 +609,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)
 
@@ -624,7 +623,7 @@ proc rawClosureCreation(owner: PSym;
         if owner.kind != skMacro:
           createTypeBoundOps(d.graph, nil, fieldAccess.typ, env.info, d.idgen)
         if tfHasAsgn in fieldAccess.typ.flags or optSeqDestructors in d.graph.config.globalOptions:
-          owner.incl sfInjectDestructors
+          owner.flags.incl sfInjectDestructors
 
   let upField = lookupInRecord(env.typ.skipTypes({tyOwned, tyRef, tyPtr}).n, getIdent(d.graph.cache, upName))
   if upField != nil:
@@ -666,7 +665,7 @@ proc closureCreationForIter(owner: PSym, iter: 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)
-  incl(v.flagsImpl, sfShadowed)
+  incl(v.flags, sfShadowed)
   v.typ = asOwnedRef(d, getHiddenParam(d.graph, iter.sym).typ)
   var vnode: PNode
   if iterOwner.isIterator:
@@ -787,7 +786,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:
@@ -975,20 +974,6 @@ proc liftForLoop*(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner: PSym):
       for i in 0..<op.len-1:
         result.add op[i]
 
-  elif op.kind != nkSym: # might have side effects
-    # bug #25046
-    # create a temp for the closure
-    # var :closureTemp
-    # :closureTemp = ...
-    let tempSym = newSym(skLet, getIdent(g.cache, ":closureTemp"), idgen, owner, body.info)
-    tempSym.typ = call[0].typ
-    let temp = newSymNode(tempSym)
-    var v = newNodeI(nkVarSection, body.info)
-    addVar(v, temp)
-    result.add(v)
-    result.add newAsgnStmt(temp, call[0], body.info)
-    call[0] = temp
-
   var loopBody = newNodeI(nkStmtList, body.info, 3)
   var whileLoop = newNodeI(nkWhileStmt, body.info, 2)
   whileLoop[0] = newIntTypeNode(1, getSysType(g, body.info, tyBool))

compiler/layeredtable.nim

@@ -1,5 +1,5 @@
-import std/[tables]
-import ast, astalgo
+import std/tables
+import ast
 
 type
   LayeredIdTableObj* {.acyclic.} = object
@@ -28,15 +28,14 @@ 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)
-  #copyIdTable(result.topLayer, pt.topLayer)
 
 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.counter
+  pt.previousLen + pt.topLayer.len
 
 proc newTypeMapLayer*(pt: LayeredIdTable): LayeredIdTable =
-  result = LayeredIdTable(topLayer: initTypeMapping(), previousLen: pt.currentLen)
+  result = LayeredIdTable(topLayer: initTable[ItemId, PType](), previousLen: pt.currentLen)
   when useRef:
     result.nextLayer = pt
   else:
@@ -54,15 +53,6 @@ proc setToPreviousLayer*(pt: var LayeredIdTable) {.inline.} =
       let tmp = pt.nextLayer[]
       pt = tmp
 
-iterator pairs*(pt: LayeredIdTable): (ItemId, PType) =
-  var tm = pt
-  while true:
-    for (k, v) in idTablePairs(tm.topLayer):
-      yield (k, v)
-    if tm.nextLayer == nil:
-      break
-    tm.setToPreviousLayer
-
 proc lookup(typeMap: ref LayeredIdTableObj, key: ItemId): PType =
   result = nil
   var tm = typeMap

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): PSym
+              info: TLineInfo; idgen: IdGenerator; isDistinct = false): PSym
 
 proc createTypeBoundOps*(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo;
                          idgen: IdGenerator)
@@ -49,7 +49,7 @@ 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)
@@ -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,10 +88,10 @@ 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)
+    body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc genAddr(c: var TLiftCtx; x: PNode): PNode =
   if x.kind == nkHiddenDeref:
@@ -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)
@@ -148,7 +148,7 @@ proc destructorCall(c: var TLiftCtx; op: PSym; x: PNode): PNode =
   if sfNeverRaises notin op.flags:
     c.canRaise = true
   if c.addMemReset:
-    result = newTree(nkStmtList, destroy, genBuiltin(c, mWasMoved,  "wasMoved", x))
+    result = newTree(nkStmtList, destroy, genBuiltin(c, mWasMoved,  "`=wasMoved`", x))
   else:
     result = destroy
 
@@ -168,7 +168,7 @@ proc fillBodyObj(c: var TLiftCtx; n, body, x, y: PNode; enforceDefaultOp: bool,
       defaultOp(c, f.typ, body, x.dotField(f), b)
     else:
       if enforceWasMoved:
-        body.add genBuiltin(c, mWasMoved, "wasMoved", x.dotField(f))
+        body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x.dotField(f))
       fillBody(c, f.typ, body, x.dotField(f), b)
   of nkNilLit: discard
   of nkRecCase:
@@ -218,38 +218,23 @@ 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:
-    # destroys in reverse order #24719
-    if c.kind == attachedDestructor:
-      for i in countdown(n.len-1, 0):
-        fillBodyObj(c, n[i], body, x, y, enforceDefaultOp, enforceWasMoved)
-    else:
-      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, enforceWasMoved)
   else:
     illFormedAstLocal(n, c.g.config)
 
 proc fillBodyObjTImpl(c: var TLiftCtx; t: PType, body, x, y: PNode) =
-  template fillBase =
-    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
+  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)
-  template fillFields =
-    fillBodyObj(c, t.n, body, x, y, enforceDefaultOp = false)
-
-  if c.kind == attachedDestructor:
-    # destroys in reverse order #24719
-    fillFields()
-    fillBase()
-  else:
-    fillBase()
-    fillFields()
+    fillBody(c, skipTypes(t.baseClass, abstractPtrs), body, dest, src)
+  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)
@@ -280,11 +265,11 @@ 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
-    incl(temp, sfFromGeneric)
+    incl(temp.flags, sfFromGeneric)
     var v = newNodeI(nkVarSection, c.info)
     let blob = newSymNode(temp)
     v.addVar(blob, x)
@@ -292,8 +277,7 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
     #body.add newAsgnStmt(blob, x)
 
     var wasMovedCall = newNodeI(nkCall, c.info)
-    wasMovedCall.add(newSymNode(createMagic(c.g, c.idgen, "wasMoved", mWasMoved)))
-
+    wasMovedCall.add(newSymNode(createMagic(c.g, c.idgen, "`=wasMoved`", mWasMoved)))
     wasMovedCall.add x # mWasMoved does not take the address
     body.add wasMovedCall
 
@@ -312,7 +296,7 @@ proc fillBodyObjT(c: var TLiftCtx; t: PType, body, x, y: PNode) =
 
 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}
@@ -380,10 +364,6 @@ proc requiresDestructor(c: TLiftCtx; t: PType): bool {.inline.} =
 proc instantiateGeneric(c: var TLiftCtx; op: PSym; t, typeInst: PType): PSym =
   if c.c != nil and typeInst != nil:
     result = c.c.instTypeBoundOp(c.c, op, typeInst, c.info, attachedAsgn, 1)
-  elif typeInst != nil and getAttachedOp(c.g, typeInst, c.kind) != nil:
-    # c.c == nil in lambdalifting
-    # hooks are already insted
-    result = getAttachedOp(c.g, typeInst, c.kind)
   else:
     localError(c.g.config, c.info,
       "cannot generate destructor for generic type: " & typeToString(t))
@@ -397,8 +377,7 @@ proc considerAsgnOrSink(c: var TLiftCtx; t: PType; body, x, y: PNode;
     if op != nil and op != c.fn and
         (sfOverridden in op.flags or destructorOverridden):
       if sfError in op.flags:
-        ensureMutable c.fn
-        incl c.fn.flagsImpl, sfError
+        incl c.fn.flags, sfError
       #else:
       #  markUsed(c.g.config, c.info, op, c.g.usageSym)
       onUse(c.info, op)
@@ -424,8 +403,7 @@ proc considerAsgnOrSink(c: var TLiftCtx; t: PType; body, x, y: PNode;
       if op == nil:
         op = produceSym(c.g, c.c, t, c.kind, c.info, c.idgen)
     if sfError in op.flags:
-      ensureMutable c.fn
-      incl c.fn.flagsImpl, sfError
+      incl c.fn.flags, sfError
     #else:
     #  markUsed(c.g.config, c.info, op, c.g.usageSym)
     onUse(c.info, op)
@@ -541,7 +519,7 @@ proc considerUserDefinedOp(c: var TLiftCtx; t: PType; body, x, y: PNode): bool =
 proc declareCounter(c: var TLiftCtx; body: PNode; first: BiggestInt): PNode =
   var temp = newSym(skTemp, getIdent(c.g.cache, lowerings.genPrefix), c.idgen, c.fn, c.info)
   temp.typ = getSysType(c.g, body.info, tyInt)
-  incl(temp.flagsImpl, sfFromGeneric)
+  incl(temp.flags, sfFromGeneric)
 
   var v = newNodeI(nkVarSection, c.info)
   result = newSymNode(temp)
@@ -551,7 +529,7 @@ proc declareCounter(c: var TLiftCtx; body: PNode; first: BiggestInt): PNode =
 proc declareTempOf(c: var TLiftCtx; body: PNode; value: PNode): PNode =
   var temp = newSym(skTemp, getIdent(c.g.cache, lowerings.genPrefix), c.idgen, c.fn, c.info)
   temp.typ = value.typ
-  incl(temp.flagsImpl, sfFromGeneric)
+  incl(temp.flags, sfFromGeneric)
 
   var v = newNodeI(nkVarSection, c.info)
   result = newSymNode(temp)
@@ -567,18 +545,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)
@@ -601,7 +579,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) =
@@ -634,7 +612,7 @@ proc fillSeqOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     if canFormAcycle(c.g, t.elemType):
       # follow all elements:
       forallElements(c, t, body, x, y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc useSeqOrStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   createTypeBoundOps(c.g, c.c, t, body.info, c.idgen)
@@ -672,7 +650,7 @@ proc useSeqOrStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       if op == nil:
         return # protect from recursion
       body.add newHookCall(c, op, x, y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
   of attachedDup:
     # XXX: replace these with assertions.
     let op = getAttachedOp(c.g, t, c.kind)
@@ -694,7 +672,7 @@ proc fillStrOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genBuiltin(c, mDestroy, "destroy", x)
   of attachedTrace:
     discard "strings are atomic and have no inner elements that are to trace"
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc cyclicType*(g: ModuleGraph, t: PType): bool =
   case t.kind
@@ -742,7 +720,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))
@@ -752,7 +730,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)
@@ -760,7 +738,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:
@@ -787,13 +765,13 @@ 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
         body.add callCodegenProc(c.g, "nimTraceRefDyn", c.info, genAddrOf(x, c.idgen), y)
       #echo "can follow ", elemType, " static ", isFinal(elemType)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
   of attachedDup:
     if isCyclic:
       body.add newAsgnStmt(x, y)
@@ -808,7 +786,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 =
@@ -824,7 +802,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:
@@ -836,7 +814,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)
@@ -848,7 +826,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)))
@@ -860,7 +838,7 @@ proc atomicClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace:
     body.add callCodegenProc(c.g, "nimTraceRefDyn", c.info, genAddrOf(xenv, c.idgen), y)
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc weakrefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   case c.kind
@@ -888,7 +866,7 @@ proc weakrefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       body.sons.insert(des, 0)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   var actions = newNodeI(nkStmtList, c.info)
@@ -900,7 +878,7 @@ proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   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))
@@ -916,21 +894,21 @@ proc ownedRefOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genIf(c, x, actions)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   if c.kind == attachedDeepCopy:
     # 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
@@ -939,13 +917,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:
@@ -956,11 +934,11 @@ proc closureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
         body.sons.insert(des, 0)
     of attachedDeepCopy: assert(false, "cannot happen")
     of attachedTrace: discard
-    of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+    of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 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)
@@ -974,7 +952,7 @@ proc ownedClosureOp(c: var TLiftCtx; t: PType; body, x, y: PNode) =
     body.add genIf(c, xx, actions)
   of attachedDeepCopy: assert(false, "cannot happen")
   of attachedTrace: discard
-  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+  of attachedWasMoved: body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
 
 proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
   case t.kind
@@ -1024,13 +1002,9 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
       # 'selectedGC' here to determine if we have the new runtime.
       discard considerUserDefinedOp(c, t, body, x, y)
     elif tfHasAsgn in t.flags:
-      # seqs with elements using custom hooks in refc
       if c.kind in {attachedAsgn, attachedSink, attachedDeepCopy}:
         body.add newSeqCall(c, x, y)
-      if c.kind == attachedWasMoved:
-        body.add genBuiltin(c, mWasMoved, "wasMoved", x)
-      else:
-        forallElements(c, t, body, x, y)
+      forallElements(c, t, body, x, y)
     else:
       defaultOp(c, t, body, x, y)
   of tyString:
@@ -1047,11 +1021,9 @@ proc fillBody(c: var TLiftCtx; t: PType; body, x, y: PNode) =
         of {attachedAsgn, attachedSink, attachedDup}:
           body.add newAsgnStmt(x, y)
         of attachedWasMoved:
-          body.add genBuiltin(c, mWasMoved, "wasMoved", x)
+          body.add genBuiltin(c, mWasMoved, "`=wasMoved`", x)
         else:
           fillBodyObjT(c, t, body, x, y)
-      elif tfUnion in t.flags: # bug #25236
-        defaultOp(c, t, body, x, y)
       else:
         if c.kind == attachedDup:
           var op2 = getAttachedOp(c.g, t, attachedAsgn)
@@ -1091,7 +1063,9 @@ proc produceSymDistinctType(g: ModuleGraph; c: PContext; typ: PType;
   assert typ.kind == tyDistinct
   let baseType = typ.elementType
   if getAttachedOp(g, baseType, kind) == nil:
-    discard produceSym(g, c, baseType, kind, info, idgen)
+    # 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)
   result = getAttachedOp(g, baseType, kind)
   setAttachedOp(g, idgen.module, typ, kind, result)
 
@@ -1126,10 +1100,11 @@ proc symDupPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttache
   n[bodyPos] = newNodeI(nkStmtList, info)
   n[resultPos] = newSymNode(res)
   result.ast = n
-  incl result.flagsImpl, {sfFromGeneric, sfGeneratedOp}
+  incl result.flags, sfFromGeneric
+  incl result.flags, sfGeneratedOp
 
 proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp;
-              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false): PSym =
+              info: TLineInfo; idgen: IdGenerator; isDiscriminant = false; isDistinct = false): PSym =
   if kind == attachedDup:
     return symDupPrototype(g, typ, owner, kind, info, idgen)
 
@@ -1140,7 +1115,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})):
+     ((g.config.isDefined("nimPreviewNonVarDestructor") and not isDiscriminant) or (typ.kind in {tyRef, tyString, tySequence} and not isDistinct)):
     dest.typ = typ
   else:
     dest.typ = makeVarType(typ.owner, typ, idgen)
@@ -1168,27 +1143,27 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
   n[paramsPos] = result.typ.n
   n[bodyPos] = newNodeI(nkStmtList, info)
   result.ast = n
-  incl result.flagsImpl, sfFromGeneric
-  incl result.flagsImpl, sfGeneratedOp
+  incl result.flags, sfFromGeneric
+  incl result.flags, sfGeneratedOp
   if kind == attachedWasMoved:
-    incl result.flagsImpl, sfNoSideEffect
-    incl result.typ, tfNoSideEffect
+    incl result.flags, sfNoSideEffect
+    incl result.typ.flags, tfNoSideEffect
 
 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): PSym =
+              info: TLineInfo; idgen: IdGenerator; isDistinct = false): 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)
+    result = symPrototype(g, typ, typ.owner, kind, info, idgen, isDistinct = isDistinct)
 
   var a = TLiftCtx(info: info, g: g, kind: kind, c: c, asgnForType: typ, idgen: idgen,
                    fn: result)
@@ -1205,17 +1180,14 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
 
   if kind == attachedSink and destructorOverridden(g, typ):
     ## compiler can use a combination of `=destroy` and memCopy for sink op
-    ensureMutable dest
-    dest.flagsImpl.incl sfCursor
+    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 newAsgnStmt(d, src)
   else:
     var tk: TTypeKind
-    var skipped: PType = nil
     if g.config.selectedGC in {gcArc, gcOrc, gcHooks, gcAtomicArc}:
-      skipped = skipTypes(typ, {tyOrdinal, tyRange, tyInferred, tyGenericInst, tyStatic, tyAlias, tySink})
-      tk = skipped.kind
+      tk = skipTypes(typ, {tyOrdinal, tyRange, tyInferred, tyGenericInst, tyStatic, tyAlias, tySink}).kind
     else:
       tk = tyNone # no special casing for strings and seqs
     case tk
@@ -1225,20 +1197,16 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
       fillStrOp(a, typ, result.ast[bodyPos], d, src)
     else:
       fillBody(a, typ, result.ast[bodyPos], d, src)
-      if tk == tyObject and a.kind in {attachedAsgn, attachedSink, attachedDeepCopy, attachedDup} and not isObjLackingTypeField(skipped):
+      if tk == tyObject and a.kind in {attachedAsgn, attachedSink, attachedDeepCopy, attachedDup} and not lacksMTypeField(typ):
         # bug #19205: Do not forget to also copy the hidden type field:
         genTypeFieldCopy(a, typ, result.ast[bodyPos], d, src)
 
   if not a.canRaise:
-    ensureMutable result
-    incl result.flagsImpl, sfNeverRaises
+    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 kind == attachedDestructor:
-    ensureMutable result
-    incl result.optionsImpl, optQuirky
   completePartialOp(g, idgen.module, typ, kind, result)
 
 
@@ -1263,9 +1231,7 @@ proc produceDestructorForDiscriminator*(g: ModuleGraph; typ: PType; field: PSym,
   result.ast[bodyPos].add v
   let placeHolder = newNodeIT(nkSym, info, getSysType(g, info, tyPointer))
   fillBody(a, typ, result.ast[bodyPos], d, placeHolder)
-  if not a.canRaise:
-    ensureMutable result
-    incl result.flagsImpl, sfNeverRaises
+  if not a.canRaise: incl result.flags, sfNeverRaises
 
 
 template liftTypeBoundOps*(c: PContext; typ: PType; info: TLineInfo) =
@@ -1300,7 +1266,7 @@ proc inst(g: ModuleGraph; c: PContext; t: PType; kind: TTypeAttachedOp; idgen: I
     else:
       localError(g.config, info, "unresolved generic parameter")
 
-proc isTrivial*(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;
@@ -1309,13 +1275,7 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
   ## to ensure we lift assignment, destructors and moves properly.
   ## The later 'injectdestructors' pass depends on it.
   if orig == nil or {tfCheckedForDestructor, tfHasMeta} * orig.flags != {}: return
-  # IC: review this solution again later
-  incl orig.flagsImpl, tfCheckedForDestructor
-  # for user defined generic destructors:
-  let origRoot = genericRoot(orig)
-  if origRoot != nil:
-    # IC: review this solution again later
-    incl origRoot.flagsImpl, tfGenericHasDestructor
+  incl orig.flags, tfCheckedForDestructor
 
   let skipped = orig.skipTypes({tyGenericInst, tyAlias, tySink})
   if isEmptyContainer(skipped) or skipped.kind == tyStatic: return
@@ -1341,7 +1301,7 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
   # bug #15122: We need to produce all prototypes before entering the
   # mind boggling recursion. Hacks like these imply we should rewrite
   # this module.
-  var generics = default(array[attachedWasMoved..attachedTrace, bool])
+  var generics: array[attachedWasMoved..attachedTrace, bool] = default(array[attachedWasMoved..attachedTrace, bool])
   for k in attachedWasMoved..lastAttached:
     generics[k] = getAttachedOp(g, canon, k) != nil
     if not generics[k]:
@@ -1357,9 +1317,8 @@ proc createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInf
     if canon != orig:
       setAttachedOp(g, idgen.module, orig, k, getAttachedOp(g, canon, k))
 
-  if not isTrivial(getAttachedOp(g, orig, attachedDestructor)):
-    #or not isTrivial(orig.assignment) or
-    # not isTrivial(orig.sink):
-    # IC: review this solution again later
-    orig.flagsImpl.incl tfHasAsgn
+  if not isTrival(getAttachedOp(g, orig, attachedDestructor)):
+    #or not isTrival(orig.assignment) or
+    # not isTrival(orig.sink):
+    orig.flags.incl tfHasAsgn
     # ^ XXX Breaks IC!

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

@@ -94,7 +94,6 @@ type
     warnImplicitDefaultValue = "ImplicitDefaultValue",
     warnIgnoredSymbolInjection = "IgnoredSymbolInjection",
     warnStdPrefix = "StdPrefix"
-    warnUnknownNotes = "UnknownNotes"
     warnUser = "User",
     warnGlobalVarConstructorTemporary = "GlobalVarConstructorTemporary",
     # hints
@@ -110,9 +109,9 @@ type
     hintSource = "Source", hintPerformance = "Performance", hintStackTrace = "StackTrace",
     hintGCStats = "GCStats", hintGlobalVar = "GlobalVar", hintExpandMacro = "ExpandMacro",
     hintUser = "User", hintUserRaw = "UserRaw", hintExtendedContext = "ExtendedContext",
-    hintUnknownRaises = "UnknownRaises",
     hintMsgOrigin = "MsgOrigin", # since 1.3.5
     hintDeclaredLoc = "DeclaredLoc", # since 1.5.1
+    hintUnknownHint = "UnknownHint"
 
 const
   MsgKindToStr*: array[TMsgKind, string] = [
@@ -201,7 +200,6 @@ const
     warnImplicitDefaultValue: "$1",
     warnIgnoredSymbolInjection: "$1",
     warnStdPrefix: "$1 needs the 'std' prefix",
-    warnUnknownNotes: "$1",
     warnUser: "$1",
     warnGlobalVarConstructorTemporary: "global variable '$1' initialization requires a temporary variable",
     hintSuccess: "operation successful: $#",
@@ -237,9 +235,9 @@ const
     hintUser: "$1",
     hintUserRaw: "$1",
     hintExtendedContext: "$1",
-    hintUnknownRaises: "$1 is a forward declaration without explicit .raises, assuming it can raise anything",
     hintMsgOrigin: "$1",
-    hintDeclaredLoc: "$1"
+    hintDeclaredLoc: "$1",
+    hintUnknownHint: "unknown hint: $1"
   ]
 
 const
@@ -273,10 +271,6 @@ const
   errFloatToString* = "cannot convert '$1' to '$2'"
 
 type
-  FileInfoKind* = enum
-    fikSource,      ## A real source file path
-    fikNifModule    ## A NIF module suffix (not a real path)
-
   TFileInfo* = object
     fullPath*: AbsoluteFile    # This is a canonical full filesystem path
     projPath*: RelativeFile    # This is relative to the project's root
@@ -295,7 +289,6 @@ type
                                # for 'nimsuggest'
     hash*: string              # the checksum of the file
     dirty*: bool               # for 'nimpretty' like tooling
-    kind*: FileInfoKind        # distinguishes real files from NIF suffixes
     when defined(nimpretty):
       fullContent*: string
   FileIndex* = distinct int32

compiler/llstream.nim

@@ -11,7 +11,7 @@
 
 import
   pathutils
-import std/strutils
+
 when defined(nimPreviewSlimSystem):
   import std/syncio
 
@@ -86,47 +86,6 @@ const
   LineContinuationOprs = {'+', '-', '*', '/', '\\', '<', '>', '!', '?', '^',
                           '|', '%', '&', '$', '@', '~', ','}
   AdditionalLineContinuationOprs = {'#', ':', '='}
-  LineContinuationTokens = [
-    "let", "var", "const", "type",  # section
-    "object", "tuple",
-    # from ./layouter.oprSet
-    "div", "mod", "shl", "shr", "in", "notin", "is",
-    "isnot", "not", "of", "as", "from", "..", "and", "or", "xor", 
-  ]  # must be all `nimIdentNormalized`-ed
-
-proc eqIdent(a, bNormalized: string): bool =
-  a.nimIdentNormalize == bNormalized
-
-proc endsWithIdent(s, subs: string): bool =
-  let le = subs.len
-  if le > s.len: return false
-  s[^le .. ^1].eqIdent subs
-
-proc continuesWithIdent(s, subs: string, start: int): bool =
-  s.substr(start, start+subs.high).eqIdent subs
-
-proc endsWithIdent(s, subs: string, endIdx: var int): bool =
-  endIdx.dec subs.len
-  result = s.continuesWithIdent(subs, endIdx+1)
-
-proc containsObjectOf(x: string): bool =
-  const sep = ' '
-  var idx = x.rfind(sep)
-  if idx == -1: return
-  template eatWord(word) =  
-    while x[idx] == sep: idx.dec
-    result = x.endsWithIdent(word, idx)
-    if not result: return
-  eatWord "of"
-  eatWord "object"
-  result = true
-
-proc endsWithLineContinuationToken(x: string): bool =
-  result = false
-  for tok in LineContinuationTokens:
-    if x.endsWithIdent(tok):
-      return true
-  result = x.containsObjectOf
 
 proc endsWithOpr*(x: string): bool =
   result = x.endsWith(LineContinuationOprs)
@@ -134,9 +93,7 @@ proc endsWithOpr*(x: string): bool =
 proc continueLine(line: string, inTripleString: bool): bool {.inline.} =
   result = inTripleString or line.len > 0 and (
         line[0] == ' ' or
-        line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs) or
-        line.endsWithLineContinuationToken()
-      )
+        line.endsWith(LineContinuationOprs+AdditionalLineContinuationOprs))
 
 proc countTriples(s: string): int =
   result = 0
@@ -152,10 +109,7 @@ proc llReadFromStdin(s: PLLStream, buf: pointer, bufLen: int): int =
   s.rd = 0
   var line = newStringOfCap(120)
   var triples = 0
-  while true:
-    if not readLineFromStdin(if s.s.len == 0: ">>> " else: "... ", line):
-      # now readLineFromStdin meets EOF (ctrl-D/Z) or ctrl-C
-      quit()
+  while readLineFromStdin(if s.s.len == 0: ">>> " else: "... ", line):
     s.s.add(line)
     s.s.add("\n")
     inc triples, countTriples(line)

compiler/lookups.nim

@@ -58,11 +58,13 @@ proc considerQuotedIdent*(c: PContext; n: PNode, origin: PNode = nil): PIdent =
         of nkLiterals - nkFloatLiterals: id.add(x.renderTree)
         else: handleError(n, origin)
       result = getIdent(c.cache, id)
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+  of nkOpenSymChoice, nkClosedSymChoice:
     if n[0].kind == nkSym:
       result = n[0].sym.name
     else:
       handleError(n, origin)
+  of nkOpenSym:
+    result = considerQuotedIdent(c, n[0], origin)
   else:
     handleError(n, origin)
 
@@ -75,13 +77,10 @@ proc addUniqueSym*(scope: PScope, s: PSym): PSym =
 proc openScope*(c: PContext): PScope {.discardable.} =
   result = PScope(parent: c.currentScope,
                   symbols: initStrTable(),
-                  depthLevel: c.scopeDepth + 1,
-                  optionStackLen: c.optionStack.len)
+                  depthLevel: c.scopeDepth + 1)
   c.currentScope = result
 
 proc rawCloseScope*(c: PContext) =
-  if c.currentScope.optionStackLen >= 1:
-    c.optionStack.setLen(c.currentScope.optionStackLen)
   c.currentScope = c.currentScope.parent
 
 proc closeScope*(c: PContext) =
@@ -222,14 +221,7 @@ proc debugScopes*(c: PContext; limit=0, max = int.high) {.deprecated.} =
     if i == limit: return
     inc i
 
-proc searchImportsAll*(c: PContext, s: PIdent, filter: TSymKinds, holding: var seq[PSym]) =
-  var marked = initIntSet()
-  for im in c.imports.mitems:
-    for s in symbols(im, marked, s, c.graph):
-      if s.kind in filter:
-        holding.add s
-
-proc searchScopes*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
+proc searchInScopesAllCandidatesFilterBy*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
   result = @[]
   for scope in allScopes(c.currentScope):
     var ti: TIdentIter = default(TIdentIter)
@@ -239,12 +231,14 @@ proc searchScopes*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
         result.add candidate
       candidate = nextIdentIter(ti, scope.symbols)
 
-proc searchScopesAll*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
-  result = searchScopes(c,s,filter)
   if result.len == 0:
-    searchImportsAll(c, s, filter, result)
+    var marked = initIntSet()
+    for im in c.imports.mitems:
+      for s in symbols(im, marked, s, c.graph):
+        if s.kind in filter:
+          result.add s
 
-proc selectFromScopesElseAll*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
+proc searchInScopesFilterBy*(c: PContext, s: PIdent, filter: TSymKinds): seq[PSym] =
   result = @[]
   block outer:
     for scope in allScopes(c.currentScope):
@@ -258,7 +252,11 @@ proc selectFromScopesElseAll*(c: PContext, s: PIdent, filter: TSymKinds): seq[PS
         candidate = nextIdentIter(ti, scope.symbols)
 
   if result.len == 0:
-    searchImportsAll(c, s, filter, result)
+    var marked = initIntSet()
+    for im in c.imports.mitems:
+      for s in symbols(im, marked, s, c.graph):
+        if s.kind in filter:
+          result.add s
 
 proc cmpScopes*(ctx: PContext, s: PSym): int =
   # Do not return a negative number
@@ -311,7 +309,7 @@ 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.flagsImpl, sfDiscardable)
+  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)
@@ -388,7 +386,7 @@ proc addDeclAt*(c: PContext; scope: PScope, sym: PSym, info: TLineInfo) =
   if sym.name.id == ord(wUnderscore): return
   let conflict = scope.addUniqueSym(sym)
   if conflict != nil:
-    if sym.kind == skModule and conflict.kind == skModule and not c.config.isDefined("nimPreviewDuplicateModuleError"):
+    if sym.kind == skModule and conflict.kind == skModule:
       # e.g.: import foo; import foo
       # xxx we could refine this by issuing a different hint for the case
       # where a duplicate import happens inside an include.
@@ -646,7 +644,7 @@ const allExceptModule = {low(TSymKind)..high(TSymKind)} - {skModule, skPackage}
 
 proc lookUpCandidates*(c: PContext, ident: PIdent, filter: set[TSymKind],
                        includePureEnum = false): seq[PSym] =
-  result = selectFromScopesElseAll(c, ident, filter)
+  result = searchInScopesFilterBy(c, ident, filter)
   if skEnumField in filter and (result.len == 0 or includePureEnum):
     result.add allPureEnumFields(c, ident)
 
@@ -727,7 +725,7 @@ proc qualifiedLookUp*(c: PContext, n: PNode, flags: set[TLookupFlag]): PSym =
 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`
+    # for now it only seems this is called for `pickSym` in `getTypeIdent` 
     return initOverloadIter(o, c, n[0])
   o.importIdx = -1
   o.marked = initIntSet()

compiler/lowerings.nim

@@ -82,7 +82,7 @@ proc lowerTupleUnpacking*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: P
     var temp = newSym(skTemp, getIdent(g.cache, genPrefix), idgen,
                   owner, value.info, g.config.options)
     temp.typ = skipTypes(value.typ, abstractInst)
-    incl(temp.flagsImpl, sfFromGeneric)
+    incl(temp.flags, sfFromGeneric)
     tempAsNode = newSymNode(temp)
 
   var v = newNodeI(nkVarSection, value.info)
@@ -103,7 +103,7 @@ proc evalOnce*(g: ModuleGraph; value: PNode; idgen: IdGenerator; owner: PSym): P
   var temp = newSym(skTemp, getIdent(g.cache, genPrefix), idgen,
                     owner, value.info, g.config.options)
   temp.typ = skipTypes(value.typ, abstractInst)
-  incl(temp.flagsImpl, sfFromGeneric)
+  incl(temp.flags, sfFromGeneric)
 
   var v = newNodeI(nkLetSection, value.info)
   let tempAsNode = newSymNode(temp)
@@ -127,8 +127,8 @@ proc lowerSwap*(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNod
   # note: cannot use 'skTemp' here cause we really need the copy for the VM :-(
   var temp = newSym(skVar, getIdent(g.cache, genPrefix), idgen, owner, n.info, owner.options)
   temp.typ = n[1].typ
-  incl(temp.flagsImpl, sfFromGeneric)
-  incl(temp.flagsImpl, sfGenSym)
+  incl(temp.flags, sfFromGeneric)
+  incl(temp.flags, sfGenSym)
 
   var v = newNodeI(nkVarSection, n.info)
   let tempAsNode = newSymNode(temp)
@@ -147,13 +147,13 @@ proc createObj*(g: ModuleGraph; idgen: IdGenerator; owner: PSym, info: TLineInfo
   result = newType(tyObject, idgen, owner)
   if final:
     rawAddSon(result, nil)
-    incl result, tfFinal
+    incl result.flags, tfFinal
   else:
     rawAddSon(result, getCompilerProc(g, "RootObj").typ)
   result.n = newNodeI(nkRecList, info)
   let s = newSym(skType, getIdent(g.cache, "Env_" & toFilename(g.config, info) & "_" & $owner.name.s),
                   idgen, owner, info, owner.options)
-  incl s.flagsImpl, sfAnon
+  incl s.flags, sfAnon
   s.typ = result
   result.sym = s
 
@@ -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,12 +250,12 @@ 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).elementType
   var t = deref.typ.skipTypes(abstractInst)
   var field: PSym
   while true:
@@ -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).elementType
   var t = deref.typ.skipTypes(abstractInst)
   var field: PSym
   let bb = getIdent(cache, b)
@@ -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
@@ -320,7 +320,7 @@ 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 =
@@ -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.returnType
 
 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

@@ -166,4 +166,4 @@ proc makeAddr*(n: PNode; idgen: IdGenerator): PNode =
     result = n
   else:
     result = newTree(nkHiddenAddr, n)
-    result.typ = makePtrType(n.typ.skipTypes({tySink}), idgen)
+    result.typ() = makePtrType(n.typ, idgen)

compiler/main.nim

@@ -32,10 +32,6 @@ import ../dist/checksums/src/checksums/sha1
 
 import pipelines
 
-when not defined(nimKochBootstrap):
-  import nifbackend
-  import deps
-
 when not defined(leanCompiler):
   import docgen
 
@@ -121,38 +117,6 @@ when not defined(leanCompiler):
     else: raiseAssert $ext
     compilePipelineProject(graph)
 
-proc commandCompileToNif(graph: ModuleGraph) =
-  let conf = graph.config
-  extccomp.initVars(conf)
-  if conf.symbolFiles == disabledSf:
-    if {optRun, optForceFullMake} * conf.globalOptions == {optRun} or isDefined(conf, "nimBetterRun"):
-      if not changeDetectedViaJsonBuildInstructions(conf, conf.jsonBuildInstructionsFile):
-        # nothing changed
-        graph.config.notes = graph.config.mainPackageNotes
-        return
-
-  if not extccomp.ccHasSaneOverflow(conf):
-    conf.symbols.defineSymbol("nimEmulateOverflowChecks")
-
-  setPipeLinePass(graph, NifgenPass)
-  compilePipelineProject(graph)
-
-proc commandNifC(graph: ModuleGraph) =
-  ## Generate C code from precompiled NIF files.
-  ## This is the new IC approach: compile modules to NIF first with `nim m`,
-  ## then generate C code from the entry.nif file with whole-program DCE.
-  when not defined(nimKochBootstrap):
-    let conf = graph.config
-    extccomp.initVars(conf)
-
-    if not extccomp.ccHasSaneOverflow(conf):
-      conf.symbols.defineSymbol("nimEmulateOverflowChecks")
-
-    # Use the NIF backend to generate C code
-    nifbackend.generateCode(graph, conf.projectMainIdx)
-  else:
-    rawMessage(graph.config, errGenerated, "NIF backend not available during bootstrap build")
-
 proc commandCompileToC(graph: ModuleGraph) =
   let conf = graph.config
   extccomp.initVars(conf)
@@ -220,7 +184,7 @@ proc commandInteractive(graph: ModuleGraph) =
     discard graph.compilePipelineModule(fileInfoIdx(graph.config, graph.config.projectFull), {})
   else:
     var m = graph.makeStdinModule()
-    incl(m, sfMainModule)
+    incl(m.flags, sfMainModule)
     var idgen = IdGenerator(module: m.itemId.module, symId: m.itemId.item, typeId: 0)
     let s = llStreamOpenStdIn(onPrompt = proc() = flushDot(graph.config))
     discard processPipelineModule(graph, m, idgen, s)
@@ -293,7 +257,7 @@ proc mainCommand*(graph: ModuleGraph) =
       if conf.exc == excNone: conf.exc = excSetjmp
     of backendCpp:
       if conf.exc == excNone: conf.exc = excCpp
-    of backendObjc, backendNif: discard
+    of backendObjc: discard
     of backendJs:
       if conf.hcrOn:
         # XXX: At the moment, system.nim cannot be compiled in JS mode
@@ -311,7 +275,6 @@ proc mainCommand*(graph: ModuleGraph) =
     of backendCpp: commandCompileToC(graph)
     of backendObjc: commandCompileToC(graph)
     of backendJs: commandCompileToJS(graph)
-    of backendNif: commandCompileToNif(graph)
     of backendInvalid: raiseAssert "unreachable"
 
   template docLikeCmd(body) =
@@ -440,22 +403,9 @@ proc mainCommand*(graph: ModuleGraph) =
   of cmdCheck:
     commandCheck(graph)
   of cmdM:
-    # cmdM uses NIF files, not ROD files
-    graph.config.symbolFiles = disabledSf
-    setUseIc(false)
+    graph.config.symbolFiles = v2Sf
+    setUseIc(graph.config.symbolFiles != disabledSf)
     commandCheck(graph)
-  of cmdNifC:
-    # Generate C code from NIF files
-    wantMainModule(conf)
-    setOutFile(conf)
-    commandNifC(graph)
-  of cmdDeps:
-    # Generate .build.nif for nifmake
-    wantMainModule(conf)
-    when not defined(nimKochBootstrap):
-      commandDeps(conf)
-    else:
-      rawMessage(conf, errGenerated, "nim deps not available in bootstrap build")
   of cmdParse:
     wantMainModule(conf)
     discard parseFile(conf.projectMainIdx, cache, conf)

compiler/modulegraphs.nim

@@ -16,9 +16,6 @@ import ../dist/checksums/src/checksums/md5
 import ast, astalgo, options, lineinfos,idents, btrees, ropes, msgs, pathutils, packages, suggestsymdb
 import ic / [packed_ast, ic]
 
-when not defined(nimKochBootstrap):
-  import ast2nif
-  import "../dist/nimony/src/lib" / [nifstreams, bitabs]
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
@@ -63,7 +60,6 @@ type
     SemPass
     JSgenPass
     CgenPass
-    NifgenPass
     EvalPass
     InterpreterPass
     GenDependPass
@@ -140,9 +136,6 @@ type
 
     cachedFiles*: StringTableRef
 
-    procGlobals*: seq[PNode]
-    nifReplayActions*: Table[int32, seq[PNode]]  # module position -> replay actions for NIF
-
   TPassContext* = object of RootObj # the pass's context
     idgen*: IdGenerator
   PPassContext* = ref TPassContext
@@ -368,10 +361,6 @@ proc setAttachedOp*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp;
   ## we also need to record this to the packed module.
   g.attachedOps[op][t.itemId] = LazySym(sym: value)
 
-proc setAttachedOp*(g: ModuleGraph; module: int; typeId: ItemId; op: TTypeAttachedOp; value: PSym) =
-  ## Overload that takes ItemId directly, useful for registering hooks from NIF index.
-  g.attachedOps[op][typeId] = LazySym(sym: value)
-
 proc setAttachedOpPartial*(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym) =
   ## we also need to record this to the packed module.
   g.attachedOps[op][t.itemId] = LazySym(sym: value)
@@ -399,10 +388,6 @@ proc setMethodsPerType*(g: ModuleGraph; id: ItemId, methods: seq[LazySym]) =
   # TODO: add it for packed modules
   g.methodsPerType[id] = methods
 
-proc addNifReplayAction*(g: ModuleGraph; module: int32; n: PNode) =
-  ## Stores a replay action for NIF-based incremental compilation.
-  g.nifReplayActions.mgetOrPut(module, @[]).add n
-
 iterator getMethodsPerType*(g: ModuleGraph; t: PType): PSym =
   if g.methodsPerType.contains(t.itemId):
     for it in mitems g.methodsPerType[t.itemId]:
@@ -435,30 +420,7 @@ proc copyTypeProps*(g: ModuleGraph; module: int; dest, src: PType) =
 
 proc loadCompilerProc*(g: ModuleGraph; name: string): PSym =
   result = nil
-  if g.config.symbolFiles == disabledSf:
-    # For NIF-based compilation, search in loaded NIF modules
-    when not defined(nimKochBootstrap):
-      # Only try to resolve from NIF if we're actually using NIF files (cmdNifC)
-      if g.config.cmd == cmdNifC:
-        # First try system module (most compilerprocs are there)
-        let systemFileIdx = g.config.m.systemFileIdx
-        if systemFileIdx != InvalidFileIdx:
-          result = tryResolveCompilerProc(ast.program, name, systemFileIdx)
-          if result != nil:
-            strTableAdd(g.compilerprocs, result)
-            return result
-
-        # Try threadpool module (some compilerprocs like FlowVar are there)
-        # Find threadpool module by searching loaded modules
-        for moduleIdx in 0..<g.ifaces.len:
-          let module = g.ifaces[moduleIdx].module
-          if module != nil and module.name.s == "threadpool":
-            let threadpoolFileIdx = module.position.FileIndex
-            result = tryResolveCompilerProc(ast.program, name, threadpoolFileIdx)
-            if result != nil:
-              strTableAdd(g.compilerprocs, result)
-              return result
-    return nil
+  if g.config.symbolFiles == disabledSf: return nil
 
   # slow, linear search, but the results are cached:
   for module in 0..<len(g.packed):
@@ -492,10 +454,10 @@ template getPContext(): untyped =
   else: c.c
 
 when defined(nimsuggest):
-  template onUse*(info: TLineInfo; s: PSym; isGenericInstance = false) = discard
+  template onUse*(info: TLineInfo; s: PSym) = discard
   template onDefResolveForward*(info: TLineInfo; s: PSym) = discard
 else:
-  template onUse*(info: TLineInfo; s: PSym; isGenericInstance = false) = discard
+  template onUse*(info: TLineInfo; s: PSym) = discard
   template onDef*(info: TLineInfo; s: PSym) = discard
   template onDefResolveForward*(info: TLineInfo; s: PSym) = discard
 
@@ -621,7 +583,6 @@ proc newModuleGraph*(cache: IdentCache; config: ConfigRef): ModuleGraph =
   result.config = config
   result.cache = cache
   initModuleGraphFields(result)
-  ast.setupProgram(config, cache)
 
 proc resetAllModules*(g: ModuleGraph) =
   g.packageSyms = initStrTable()
@@ -717,13 +678,13 @@ proc markDirty*(g: ModuleGraph; fileIdx: FileIndex) =
   if m != nil:
     g.suggestSymbols.del(fileIdx)
     g.suggestErrors.del(fileIdx)
-    incl m.flagsImpl, sfDirty
+    incl m.flags, sfDirty
 
 proc unmarkAllDirty*(g: ModuleGraph) =
   for i in 0i32..<g.ifaces.len.int32:
     let m = g.ifaces[i].module
     if m != nil:
-      m.flagsImpl.excl sfDirty
+      m.flags.excl sfDirty
 
 proc isDirty*(g: ModuleGraph; m: PSym): bool =
   result = g.suggestMode and sfDirty in m.flags
@@ -776,64 +737,6 @@ proc moduleFromRodFile*(g: ModuleGraph; fileIdx: FileIndex;
   else:
     result = nil
 
-when not defined(nimKochBootstrap):
-  proc moduleFromNifFile*(g: ModuleGraph; fileIdx: FileIndex;
-                          cachedModules: var seq[FileIndex];
-                          loadFullAst: bool = false): PSym =
-    ## Returns 'nil' if the module needs to be recompiled.
-    ## Loads module from NIF file when optCompress is enabled.
-    ## When loadFullAst is true, loads the complete module AST for code generation.
-
-    if not fileExists(toNifFilename(g.config, fileIdx)):
-      return nil
-
-    # Create module symbol
-    let filename = AbsoluteFile toFullPath(g.config, fileIdx)
-    result = PSym(
-      kindImpl: skModule,
-      itemId: ItemId(module: int32(fileIdx), item: 0'i32),
-      name: getIdent(g.cache, splitFile(filename).name),
-      infoImpl: newLineInfo(fileIdx, 1, 1),
-      positionImpl: int(fileIdx),
-    )
-    setOwner(result, getPackage(g.config, g.cache, fileIdx))
-
-    # Register module in graph
-    registerModule(g, result)
-    var hooks = initTable[nifstreams.SymId, HooksPerType]()
-    var converters: seq[(string, string)] = @[]
-    var classes: seq[ClassIndexEntry] = @[]
-    result.astImpl = loadNifModule(ast.program, fileIdx, g.ifaces[fileIdx.int].interf,
-                                   g.ifaces[fileIdx.int].interfHidden, hooks, converters, classes, loadFullAst)
-    # Register hooks from NIF index with the module graph
-    for typSymId, hooksPerType in hooks:
-      let typeItemId = parseTypeSymIdToItemId(ast.program, typSymId)
-      if typeItemId.module >= 0:
-        for op in AttachedOp:
-          let (hookSymId, isGeneric) = hooksPerType.a[op]
-          if hookSymId != nifstreams.SymId(0):
-            let hookSym = resolveHookSym(ast.program, hookSymId)
-            if hookSym != nil:
-              setAttachedOp(g, int(fileIdx), typeItemId, toTTypeAttachedOp(op), hookSym)
-    # Register converters from NIF index with the module's interface
-    for (destType, convSym) in converters:
-      let symId = pool.syms.getOrIncl(convSym)
-      let convPSym = resolveHookSym(ast.program, symId)  # reuse hook resolution
-      if convPSym != nil:
-        g.ifaces[fileIdx.int].converters.add LazySym(sym: convPSym)
-    # Register methods per type from NIF index
-    for classEntry in classes:
-      let typeItemId = parseTypeSymIdToItemId(ast.program, classEntry.cls)
-      if typeItemId.module >= 0:
-        var methodSyms: seq[LazySym] = @[]
-        for methodEntry in classEntry.methods:
-          let methodSym = resolveHookSym(ast.program, methodEntry.fn)
-          if methodSym != nil:
-            methodSyms.add LazySym(sym: methodSym)
-        if methodSyms.len > 0:
-          setMethodsPerType(g, typeItemId, methodSyms)
-    cachedModules.add fileIdx
-
 proc configComplete*(g: ModuleGraph) =
   rememberStartupConfig(g.startupPackedConfig, g.config)
 
@@ -858,7 +761,7 @@ proc getPackage*(graph: ModuleGraph; fileIdx: FileIndex): PSym =
     result = pkgSym
     graph.packageSyms.strTableAdd(pkgSym)
 
-proc belongsToStdlib*(graph: ModuleGraph, sym: PSym): bool =
+func belongsToStdlib*(graph: ModuleGraph, sym: PSym): bool =
   ## Check if symbol belongs to the 'stdlib' package.
   sym.getPackageSymbol.getPackageId == graph.systemModule.getPackageId
 

compiler/modulepaths.nim

@@ -79,10 +79,6 @@ proc checkModuleName*(conf: ConfigRef; n: PNode; doLocalError=true): FileIndex =
   else:
     result = fileInfoIdx(conf, fullPath)
 
-type
-  SelectedBase = enum
-    FromProject, FromSearchPath, FromNimblePath
-
 proc mangleModuleName*(conf: ConfigRef; path: AbsoluteFile): string =
   ## Mangle a relative module path to avoid path and symbol collisions.
   ##
@@ -91,27 +87,9 @@ proc mangleModuleName*(conf: ConfigRef; path: AbsoluteFile): string =
   ##
   ## Example:
   ## `foo-#head/../bar` becomes `@foo-@hhead@s..@sbar`
-  var best = relativeTo(path, conf.projectPath).string
-  var selectedBase = FromProject
-  for x in conf.searchPaths:
-    let other = relativeTo(path, x).string
-    if other.len < best.len:
-      best = other
-      selectedBase = FromSearchPath
-  for x in conf.nimblePaths:
-    let other = relativeTo(path, x).string
-    if other.len < best.len:
-      best = other
-      selectedBase = FromNimblePath
-  let prefix =
-    case selectedBase
-    of FromProject: "@m"
-    of FromSearchPath: "@p"
-    of FromNimblePath: "@n"
-
-  prefix & best.multiReplace(
+  "@m" & relativeTo(path, conf.projectPath).string.multiReplace(
     {$os.DirSep: "@s", $os.AltSep: "@s", "#": "@h", "@": "@@", ":": "@c"})
 
 proc demangleModuleName*(path: string): string =
   ## Demangle a relative module path.
-  result = path.multiReplace({"@@": "@", "@h": "#", "@s": "/", "@m": "", "@p": "", "@n": "", "@c": ":"})
+  result = path.multiReplace({"@@": "@", "@h": "#", "@s": "/", "@m": "", "@c": ":"})

compiler/modules.nim

@@ -32,9 +32,9 @@ proc newModule*(graph: ModuleGraph; fileIdx: FileIndex): PSym =
   let filename = AbsoluteFile toFullPath(graph.config, fileIdx)
   # We cannot call ``newSym`` here, because we have to circumvent the ID
   # mechanism, which we do in order to assign each module a persistent ID.
-  result = PSym(kindImpl: skModule, itemId: ItemId(module: int32(fileIdx), item: 0'i32),
+  result = PSym(kind: skModule, itemId: ItemId(module: int32(fileIdx), item: 0'i32),
                 name: getModuleIdent(graph, filename),
-                infoImpl: newLineInfo(fileIdx, 1, 1))
+                info: newLineInfo(fileIdx, 1, 1))
   if not isNimIdentifier(result.name.s):
     rawMessage(graph.config, errGenerated, "invalid module name: '" & result.name.s &
               "'; a module name must be a valid Nim identifier.")

compiler/msgs.nim

@@ -60,12 +60,11 @@ proc makeCString*(s: string): Rope =
     toCChar(s[i], result)
   result.add('\"')
 
-proc newFileInfo(fullPath: AbsoluteFile, projPath: RelativeFile; kind = fikSource): TFileInfo =
+proc newFileInfo(fullPath: AbsoluteFile, projPath: RelativeFile): TFileInfo =
   result = TFileInfo(fullPath: fullPath, projPath: projPath,
                     shortName: fullPath.extractFilename,
                     quotedFullName: fullPath.string.makeCString,
-                    lines: @[],
-                    kind: kind
+                    lines: @[]
   )
   result.quotedName = result.shortName.makeCString
   when defined(nimpretty):
@@ -134,23 +133,6 @@ proc fileInfoIdx*(conf: ConfigRef; filename: RelativeFile): FileIndex =
   var dummy: bool = false
   fileInfoIdx(conf, AbsoluteFile expandFilename(filename.string), dummy)
 
-proc registerNifSuffix*(conf: ConfigRef; suffix: string; isKnownFile: var bool): FileIndex =
-  result = conf.m.filenameToIndexTbl.getOrDefault(suffix, InvalidFileIdx)
-  if result == InvalidFileIdx:
-    isKnownFile = false
-    result = conf.m.fileInfos.len.FileIndex
-    conf.m.fileInfos.add(newFileInfo(AbsoluteFile suffix, RelativeFile suffix, fikNifModule))
-    conf.m.filenameToIndexTbl[suffix] = result
-  else:
-    isKnownFile = true
-
-proc fileInfoKind*(conf: ConfigRef; fileIdx: FileIndex): FileInfoKind =
-  ## Returns the kind of a FileIndex (source file or NIF module suffix).
-  if fileIdx.int >= 0 and fileIdx.int < conf.m.fileInfos.len:
-    result = conf.m.fileInfos[fileIdx.int].kind
-  else:
-    result = fikSource  # Default to source for unknown indices
-
 proc newLineInfo*(fileInfoIdx: FileIndex, line, col: int): TLineInfo =
   result = TLineInfo(fileIndex: fileInfoIdx)
   if line < int high(uint16):

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.snippet)
+  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/nifbackend.nim

@@ -1,121 +0,0 @@
-#
-#
-#           The Nim Compiler
-#        (c) Copyright 2025 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## NIF-based C/C++ code generator backend.
-##
-## This module implements C code generation from precompiled NIF files.
-## It traverses the module dependency graph starting from the main module
-## and generates C code for all reachable modules.
-##
-## Usage:
-##   1. Compile modules to NIF: nim m mymodule.nim
-##   2. Generate C from NIF: nim nifc myproject.nim
-
-import std/[intsets, tables, sets, os]
-
-when defined(nimPreviewSlimSystem):
-  import std/assertions
-
-import ast, options, lineinfos, modulegraphs, cgendata, cgen,
-  pathutils, extccomp, msgs, modulepaths, idents, types, ast2nif
-
-proc loadModuleDependencies(g: ModuleGraph; mainFileIdx: FileIndex): seq[PSym] =
-  ## Traverse the module dependency graph using a stack.
-  ## Returns all modules that need code generation, in dependency order.
-  var visited = initIntSet()
-  var stack: seq[FileIndex] = @[mainFileIdx]
-  result = @[]
-  var cachedModules: seq[FileIndex] = @[]
-
-  while stack.len > 0:
-    let fileIdx = stack.pop()
-
-    if not visited.containsOrIncl(int(fileIdx)):
-      # Only load full AST for main module; others are loaded lazily by codegen
-      let isMainModule = fileIdx == mainFileIdx
-      let module = moduleFromNifFile(g, fileIdx, cachedModules, loadFullAst=isMainModule)
-      if module != nil:
-        result.add module
-        # Add dependencies to stack (they come from cachedModules)
-        for dep in cachedModules:
-          if not visited.contains(int(dep)):
-            stack.add dep
-        cachedModules.setLen(0)
-
-proc setupNifBackendModule(g: ModuleGraph; module: PSym): BModule =
-  ## Set up a BModule for code generation from a NIF module.
-  if g.backend == nil:
-    g.backend = cgendata.newModuleList(g)
-  result = cgen.newModule(BModuleList(g.backend), module, g.config)
-
-proc generateCodeForModule(g: ModuleGraph; module: PSym) =
-  ## Generate C code for a single module.
-  let moduleId = module.position
-  var bmod = BModuleList(g.backend).modules[moduleId]
-  if bmod == nil:
-    bmod = setupNifBackendModule(g, module)
-
-  # Generate code for the module's top-level statements
-  if module.ast != nil:
-    cgen.genTopLevelStmt(bmod, module.ast)
-
-  # Finalize the module (this adds it to modulesClosed)
-  # Create an empty stmt list as the init body - genInitCode in writeModule will set it up properly
-  let initStmt = newNodeI(nkStmtList, module.info)
-  finalCodegenActions(g, bmod, initStmt)
-
-  # Generate dispatcher methods
-  for disp in getDispatchers(g):
-    genProcLvl3(bmod, disp)
-
-proc generateCode*(g: ModuleGraph; mainFileIdx: FileIndex) =
-  ## Main entry point for NIF-based C code generation.
-  ## Traverses the module dependency graph and generates C code.
-
-  # Reset backend state
-  resetForBackend(g)
-  let mainModule = g.getModule(mainFileIdx)
-
-  # Also ensure system module is set up and generated if it exists
-  if g.systemModule != nil and g.systemModule != mainModule:
-    let systemBmod = BModuleList(g.backend).modules[g.systemModule.position]
-    if systemBmod == nil:
-      discard setupNifBackendModule(g, g.systemModule)
-      generateCodeForModule(g, g.systemModule)
-
-  # Load all modules in dependency order using stack traversal
-  let modules = loadModuleDependencies(g, mainFileIdx)
-  if modules.len == 0:
-    rawMessage(g.config, errGenerated,
-      "Cannot load NIF file for main module: " & toFullPath(g.config, mainFileIdx))
-    return
-
-  # Set up backend modules for all modules that need code generation
-  for module in modules:
-    discard setupNifBackendModule(g, module)
-
-  # Generate code for all modules except main (main goes last)
-  # This ensures all modules are added to modulesClosed
-  for module in modules:
-    if module != mainModule:
-      generateCodeForModule(g, module)
-
-  # Generate main module last (so all init procs are registered)
-  if mainModule != nil:
-    generateCodeForModule(g, mainModule)
-
-  # Write C files
-  if g.backend != nil:
-    cgenWriteModules(g.backend, g.config)
-
-  # Run C compiler
-  if g.config.cmd != cmdTcc:
-    extccomp.callCCompiler(g.config)
-    if not g.config.hcrOn:
-      extccomp.writeJsonBuildInstructions(g.config, g.cachedFiles)

compiler/nilcheck.nim

@@ -919,7 +919,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 +929,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)

compiler/nim.cfg

@@ -9,11 +9,6 @@ define:nimPreviewCstringConversion
 define:nimPreviewProcConversion
 define:nimPreviewRangeDefault
 define:nimPreviewNonVarDestructor
-define:nimPreviewCheckedClose
-define:nimPreviewAsmSemSymbol
-define:nimPreviewCStringComparisons
-define:nimPreviewDuplicateModuleError
-
 threads:off
 
 #import:"$projectpath/testability"

compiler/nim.nim

@@ -118,7 +118,7 @@ proc handleCmdLine(cache: IdentCache; conf: ConfigRef) =
   if conf.selectedGC == gcUnselected:
     if conf.backend in {backendC, backendCpp, backendObjc} or
         (conf.cmd in cmdDocLike and conf.backend != backendJs) or
-        conf.cmd in {cmdGendepend, cmdNifC, cmdDeps, cmdM}:
+        conf.cmd == cmdGendepend:
       initOrcDefines(conf)
 
   mainCommand(graph)

compiler/nimconf.nim

@@ -207,6 +207,7 @@ proc parseAssignment(L: var Lexer, tok: var Token;
       checkSymbol(L, tok)
       val.add($tok)
       confTok(L, tok, config, condStack)
+  config.currentConfigDir = parentDir(filename.string)
   if percent:
     processSwitch(s, strtabs.`%`(val, config.configVars,
                                 {useEnvironment, useEmpty}), passPP, info, config)
@@ -248,8 +249,6 @@ proc loadConfigs*(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef; idgen:
   setDefaultLibpath(conf)
   template readConfigFile(path) =
     let configPath = path
-    conf.currentConfigDir = configPath.splitFile.dir.string
-    setConfigVar(conf, "selfDir", conf.currentConfigDir)
     if readConfigFile(configPath, cache, conf):
       conf.configFiles.add(configPath)
 

compiler/nimeval.nim

@@ -128,7 +128,7 @@ proc createInterpreter*(scriptName: string;
     if conf.libpath.isEmpty: conf.libpath = AbsoluteDir p
 
   var m = graph.makeModule(scriptName)
-  incl(m, sfMainModule)
+  incl(m.flags, sfMainModule)
   var idgen = idGeneratorFromModule(m)
   var vm = newCtx(m, cache, graph, idgen)
   vm.mode = emRepl
@@ -168,7 +168,7 @@ proc runRepl*(r: TLLRepl;
   if supportNimscript: defineSymbol(conf.symbols, "nimconfig")
   when hasFFI: defineSymbol(graph.config.symbols, "nimffi")
   var m = graph.makeStdinModule()
-  incl(m, sfMainModule)
+  incl(m.flags, sfMainModule)
   var idgen = idGeneratorFromModule(m)
 
   if supportNimscript: graph.vm = setupVM(m, cache, "stdin", graph, idgen)

compiler/nimsets.nim

@@ -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/optimizer.nim

@@ -28,14 +28,11 @@ type
     hasReturn, hasBreak: bool
     label: PSym # can be nil
     parent: ptr BasicBlock
-    symToDel: seq[PNode]
 
   Con = object
     somethingTodo: bool
     inFinally: int
 
-proc invalidateWasMoved(c: var BasicBlock; x: PNode)
-
 proc nestedBlock(parent: var BasicBlock; kind: TNodeKind): BasicBlock =
   BasicBlock(wasMovedLocs: @[], kind: kind, hasReturn: false, hasBreak: false,
     label: nil, parent: addr(parent))
@@ -65,10 +62,6 @@ proc mergeBasicBlockInfo(parent: var BasicBlock; this: BasicBlock) {.inline.} =
   if this.hasReturn:
     parent.wasMovedLocs.setLen 0
     parent.hasReturn = true
-  elif this.symToDel.len > 0:
-    parent.symToDel = this.symToDel
-    for i in this.symToDel:
-      invalidateWasMoved(parent, i)
 
 proc wasMovedTarget(matches: var IntSet; branch: seq[PNode]; moveTarget: PNode): bool =
   result = false
@@ -156,7 +149,6 @@ proc analyse(c: var Con; b: var BasicBlock; n: PNode) =
     # any usage of the location before destruction implies we
     # cannot elide the 'wasMoved(x)':
     b.invalidateWasMoved n
-    b.symToDel.add n
 
   of nkNone..pred(nkSym), succ(nkSym)..nkNilLit, nkTypeSection, nkProcDef, nkConverterDef,
       nkMethodDef, nkIteratorDef, nkMacroDef, nkTemplateDef, nkLambda, nkDo,

compiler/options.nim

@@ -25,7 +25,7 @@ const
   useEffectSystem* = true
   useWriteTracking* = false
   hasFFI* = defined(nimHasLibFFI)
-  copyrightYear* = "2025"
+  copyrightYear* = "2024"
 
   nimEnableCovariance* = defined(nimEnableCovariance)
 
@@ -110,8 +110,6 @@ type                          # please make sure we have under 32 options
     optEnableDeepCopy         # ORC specific: enable 'deepcopy' for all types.
     optShowNonExportedFields  # for documentation: show fields that are not exported
     optJsBigInt64             # use bigints for 64-bit integers in JS
-    optItaniumMangle          # mangling follows the Itanium spec
-    optCompress               # turn on AST compression by converting it to NIF
 
   TGlobalOptions* = set[TGlobalOption]
 
@@ -141,7 +139,6 @@ type
     backendCpp = "cpp"
     backendJs = "js"
     backendObjc = "objc"
-    backendNif = "nif"
     # backendNimscript = "nimscript" # this could actually work
     # backendLlvm = "llvm" # probably not well supported; was cmdCompileToLLVM
 
@@ -174,13 +171,10 @@ type
     cmdNop
     cmdJsonscript # compile a .json build file
     # old unused: cmdInterpret, cmdDef: def feature (find definition for IDEs)
-    cmdCompileToNif
-    cmdNifC  # generate C code from NIF files
-    cmdDeps  # generate .build.nif for nifmake
 
 const
   cmdBackends* = {cmdCompileToC, cmdCompileToCpp, cmdCompileToOC,
-                  cmdCompileToJS, cmdCrun, cmdCompileToNif}
+                  cmdCompileToJS, cmdCrun}
   cmdDocLike* = {cmdDoc0, cmdDoc, cmdDoc2tex, cmdJsondoc0, cmdJsondoc,
                  cmdCtags, cmdBuildindex}
 
@@ -228,14 +222,13 @@ type
     strictEffects,
     unicodeOperators, # deadcode
     flexibleOptionalParams,
-    strictDefs, # deadcode
+    strictDefs,
     strictCaseObjects,
     inferGenericTypes,
     openSym, # remove nfDisabledOpenSym when this is default
     # alternative to above:
     genericsOpenSym
     vtables
-    typeBoundOps
 
   LegacyFeature* = enum
     allowSemcheckedAstModification,
@@ -254,8 +247,6 @@ type
       ## Useful for libraries that rely on local passC
     jsNoLambdaLifting
       ## Old transformation for closures in JS backend
-    noPanicOnExcept
-      ## don't panic on bare except
 
   SymbolFilesOption* = enum
     disabledSf, writeOnlySf, readOnlySf, v2Sf, stressTest
@@ -391,7 +382,6 @@ type
     warnCounter*: int
     errorMax*: int
     maxLoopIterationsVM*: int ## VM: max iterations of all loops
-    maxCallDepthVM*: int ## VM: max call depth
     isVmTrace*: bool
     configVars*: StringTableRef
     symbols*: StringTableRef ## We need to use a StringTableRef here as defined
@@ -410,7 +400,6 @@ type
     projectPath*: AbsoluteDir # holds a path like /home/alice/projects/nim/compiler/
     projectFull*: AbsoluteFile # projectPath/projectName
     projectIsStdin*: bool # whether we're compiling from stdin
-    stdinFile*: AbsoluteFile # Filename to use in messages for stdin
     lastMsgWasDot*: set[StdOrrKind] # the last compiler message was a single '.'
     projectMainIdx*: FileIndex # the canonical path id of the main module
     projectMainIdx2*: FileIndex # consider merging with projectMainIdx
@@ -587,7 +576,6 @@ proc newConfigRef*(): ConfigRef =
     projectPath: AbsoluteDir"", # holds a path like /home/alice/projects/nim/compiler/
     projectFull: AbsoluteFile"", # projectPath/projectName
     projectIsStdin: false, # whether we're compiling from stdin
-    stdinFile: AbsoluteFile"stdinfile",
     projectMainIdx: FileIndex(0'i32), # the canonical path id of the main module
     command: "", # the main command (e.g. cc, check, scan, etc)
     commandArgs: @[], # any arguments after the main command
@@ -609,7 +597,6 @@ proc newConfigRef*(): ConfigRef =
     arguments: "",
     suggestMaxResults: 10_000,
     maxLoopIterationsVM: 10_000_000,
-    maxCallDepthVM: 2_000,
     vmProfileData: newProfileData(),
     spellSuggestMax: spellSuggestSecretSauce,
     currentConfigDir: ""

compiler/packages.nim

@@ -33,7 +33,7 @@ proc getPackage*(conf: ConfigRef; cache: IdentCache; fileIdx: FileIndex): PSym =
     pkgIdent = getIdent(cache, pkgName)
   newSym(skPackage, pkgIdent, idGeneratorForPackage(int32(fileIdx)), nil, info)
 
-proc getPackageSymbol*(sym: PSym): PSym =
+func getPackageSymbol*(sym: PSym): PSym =
   ## Return the owning package symbol.
   assert sym != nil
   result = sym
@@ -41,18 +41,18 @@ proc getPackageSymbol*(sym: PSym): PSym =
     result = result.owner
     assert result != nil, repr(sym.info)
 
-proc getPackageId*(sym: PSym): int =
+func getPackageId*(sym: PSym): int =
   ## Return the owning package ID.
   sym.getPackageSymbol.id
 
-proc belongsToProjectPackage*(conf: ConfigRef, sym: PSym): bool =
+func belongsToProjectPackage*(conf: ConfigRef, sym: PSym): bool =
   ## Return whether the symbol belongs to the project's package.
   ##
   ## See Also:
   ## * `modulegraphs.belongsToStdlib`
   conf.mainPackageId == sym.getPackageId
 
-proc belongsToProjectPackageMaybeNil*(conf: ConfigRef, sym: PSym): bool =
+func belongsToProjectPackageMaybeNil*(conf: ConfigRef, sym: PSym): bool =
   ## Return whether the symbol belongs to the project's package.
   ## Returns `false` if `sym` is nil.
   ##

compiler/parampatterns.nim

@@ -13,7 +13,7 @@
 import ast, types, msgs, idents, renderer, wordrecg, trees,
   options
 
-import std/[strutils, assertions]
+import std/strutils
 
 # we precompile the pattern here for efficiency into some internal
 # stack based VM :-) Why? Because it's fun; I did no benchmarks to see if that
@@ -216,11 +216,6 @@ proc exprRoot*(n: PNode; allowCalls = true): PSym =
     else:
       break
 
-proc isAssignable*(owner: PSym, n: PNode): TAssignableResult
-
-proc isLentableBranch(owner: PSym, n: PNode): bool =
-  result = isAssignable(owner, n) in {arLentValue, arAddressableConst, arLentValue}
-
 proc isAssignable*(owner: PSym, n: PNode): TAssignableResult =
   ## 'owner' can be nil!
   result = arNone
@@ -313,35 +308,6 @@ proc isAssignable*(owner: PSym, n: PNode): TAssignableResult =
     # nkVarTy denotes an lvalue, but the example above is the only
     # possible code which will get us here
     result = arLValue
-  of nkIfExpr, nkIfStmt:
-    # allow 'if' expressions to be lent if all branches are lentable
-    for branch in n:
-      if branch.len == 2:
-        if not isLentableBranch(owner, branch[1]):
-          return
-      elif branch.len == 1:
-        if not isLentableBranch(owner, branch[0]):
-          return
-      else:
-        raiseAssert "Malformed `if` statement in isAssignable"
-    result = arLentValue
-  of nkCaseStmt:
-    # allow 'case' expressions to be lent if all branches are lentable
-    for i in 1 ..< n.len:
-      let branch = n[i]
-      case branch.kind
-      of nkOfBranch:
-        if not isLentableBranch(owner, branch[^1]):
-          return
-      of nkElifBranch:
-        if not isLentableBranch(owner, branch[1]):
-          return
-      of nkElse:
-        if not isLentableBranch(owner, branch[0]):
-          return
-      else:
-        raiseAssert "Malformed `case` statement in isAssignable"
-    result = arLentValue
   else:
     discard
 

compiler/parser.nim

@@ -638,9 +638,8 @@ proc semiStmtList(p: var Parser, result: PNode) =
         getTok(p)
       if p.tok.tokType == tkParRi:
         break
-      # ignore indent:
-      #elif not (sameOrNoInd(p) or realInd(p)):
-      #  parMessage(p, errInvalidIndentation)
+      elif not (sameInd(p) or realInd(p)):
+        parMessage(p, errInvalidIndentation)
       let a = complexOrSimpleStmt(p)
       if a.kind == nkEmpty:
         parMessage(p, errExprExpected, p.tok)
@@ -700,12 +699,10 @@ proc parsePar(p: var Parser): PNode =
       asgn.add b
       result.add(asgn)
       if p.tok.tokType == tkSemiColon:
-        getTok(p)
         semiStmtList(p, result)
     elif p.tok.tokType == tkSemiColon:
       # stmt context:
       result.add(a)
-      getTok(p)
       semiStmtList(p, result)
     else:
       a = colonOrEquals(p, a)
@@ -1156,10 +1153,7 @@ proc parseParamList(p: var Parser, retColon = true): PNode =
         parMessage(p, errGenerated, "the syntax is 'parameter: var T', not 'var parameter: T'")
         break
       else:
-        if p.tok.tokType in tokKeywordLow..tokKeywordHigh:
-          parMessage(p, errGenerated, "'" & $p.tok.ident.s & "' is a keyword and cannot be used as a parameter name")
-        else:
-          parMessage(p, "expected closing ')'")
+        parMessage(p, "expected closing ')'")
         break
       result.add(a)
       if p.tok.tokType notin {tkComma, tkSemiColon}: break
@@ -2113,28 +2107,12 @@ proc parseObjectCase(p: var Parser): PNode =
   #| objectBranches = objectBranch (IND{=} objectBranch)*
   #|                       (IND{=} 'elif' expr colcom objectPart)*
   #|                       (IND{=} 'else' colcom objectPart)?
-  #| objectCase = 'case' (declColonEquals / pragma)? ':'? COMMENT?
+  #| objectCase = 'case' declColonEquals ':'? COMMENT?
   #|             (IND{>} objectBranches DED
   #|             | IND{=} objectBranches)
   result = newNodeP(nkRecCase, p)
-  getTok(p)
-  if p.tok.tokType != tkOf:
-    # of case will be handled later
-    if p.tok.indent >= 0: parMessage(p, errInvalidIndentation)
-  var a: PNode
-  if p.tok.tokType in {tkSymbol, tkAccent}:
-    a = parseIdentColonEquals(p, {withPragma})
-  else:
-    a = newNodeP(nkIdentDefs, p)
-    if p.tok.tokType == tkCurlyDotLe:
-      var prag = newNodeP(nkPragmaExpr, p)
-      prag.add(p.emptyNode)
-      prag.add(parsePragma(p))
-      a.add(prag)
-    else:
-      a.add(p.emptyNode)
-    a.add(p.emptyNode)
-    a.add(p.emptyNode)
+  getTokNoInd(p)
+  var a = parseIdentColonEquals(p, {withPragma})
   result.add(a)
   if p.tok.tokType == tkColon: getTok(p)
   flexComment(p, result)

compiler/passes.nim

@@ -42,7 +42,10 @@ proc makePass*(open: TPassOpen = nil,
                process: TPassProcess = nil,
                close: TPassClose = nil,
                isFrontend = false): TPass =
-  result = (open, process, close, isFrontend)
+  result.open = open
+  result.close = close
+  result.process = process
+  result.isFrontend = isFrontend
 
 const
   maxPasses = 10
@@ -97,8 +100,8 @@ proc processModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator;
                     stream: PLLStream): bool {.discardable.} =
   if graph.stopCompile(): return true
   var
-    p: Parser = default(Parser)
-    a: TPassContextArray = default(TPassContextArray)
+    p: Parser
+    a: TPassContextArray
     s: PLLStream
     fileIdx = module.fileIdx
   prepareConfigNotes(graph, module)
@@ -173,7 +176,7 @@ proc compileModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags, fr
     let filename = AbsoluteFile toFullPath(graph.config, fileIdx)
     if result == nil:
       result = newModule(graph, fileIdx)
-      result.incl flags
+      result.flags.incl flags
       registerModule(graph, result)
       processModuleAux("import")
     else:
@@ -185,7 +188,7 @@ proc compileModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags, fr
       replayStateChanges(graph.packed.pm[m.int].module, graph)
       replayGenericCacheInformation(graph, m.int)
   elif graph.isDirty(result):
-    result.excl sfDirty
+    result.flags.excl sfDirty
     # reset module fields:
     initStrTables(graph, result)
     result.ast = nil

compiler/patterns.nim

@@ -77,7 +77,7 @@ proc inSymChoice(sc, x: PNode): bool =
     result = false
     for i in 0..<sc.len:
       if sc[i].sym == x.sym: return true
-  elif sc.kind in {nkOpenSymChoice, nkOpenSym}:
+  elif sc.kind == nkOpenSymChoice:
     # same name suffices for open sym choices!
     result = sc[0].sym.name.id == x.sym.name.id
   else:

compiler/pipelines.nim

@@ -1,11 +1,7 @@
 import sem, cgen, modulegraphs, ast, llstream, parser, msgs,
        lineinfos, reorder, options, semdata, cgendata, modules, pathutils,
-       packages, syntaxes, depends, vm, vmdef, pragmas, idents, lookups, wordrecg,
-       liftdestructors, nifgen
-
-when not defined(nimKochBootstrap):
-  import ast2nif
-  import "../dist/nimony/src/lib" / [nifstreams, bitabs]
+       packages, syntaxes, depends, vm, pragmas, idents, lookups, wordrecg,
+       liftdestructors
 
 import pipelineutils
 
@@ -27,10 +23,6 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
     result = semNode
     if bModule != nil:
       genTopLevelStmt(BModule(bModule), result)
-  of NifgenPass:
-    result = semNode
-    if bModule != nil:
-      genTopLevelNif(bModule, result)
   of JSgenPass:
     when not defined(leanCompiler):
       result = processJSCodeGen(bModule, semNode)
@@ -39,12 +31,7 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
   of GenDependPass:
     result = addDotDependency(bModule, semNode)
   of SemPass:
-    # Return the semantic node for cmdM (NIF generation needs it)
-    # For regular check, we don't need the result
-    if graph.config.cmd == cmdM:
-      result = semNode
-    else:
-      result = graph.emptyNode
+    result = graph.emptyNode
   of Docgen2Pass, Docgen2TexPass:
     when not defined(leanCompiler):
       result = processNode(bModule, semNode)
@@ -61,8 +48,7 @@ proc processPipeline(graph: ModuleGraph; semNode: PNode; bModule: PPassContext):
     raiseAssert "use setPipeLinePass to set a proper PipelinePass"
 
 proc processImplicitImports*(graph: ModuleGraph; implicits: seq[string], nodeKind: TNodeKind,
-                             m: PSym, ctx: PContext, bModule: PPassContext, idgen: IdGenerator;
-                             topLevelStmts: PNode) =
+                             m: PSym, ctx: PContext, bModule: PPassContext, idgen: IdGenerator) =
   # XXX fixme this should actually be relative to the config file!
   let relativeTo = toFullPath(graph.config, m.info)
   for module in items(implicits):
@@ -74,13 +60,8 @@ proc processImplicitImports*(graph: ModuleGraph; implicits: seq[string], nodeKin
       importStmt.add str
       message(graph.config, importStmt.info, hintProcessingStmt, $idgen[])
       let semNode = semWithPContext(ctx, importStmt)
-      if semNode == nil:
+      if semNode == nil or processPipeline(graph, semNode, bModule) == nil:
         break
-      let top = processPipeline(graph, semNode, bModule)
-      if top == nil:
-        break
-      if topLevelStmts != nil:
-        topLevelStmts.add top
 
 proc prePass*(c: PContext; n: PNode) =
   for son in n:
@@ -102,7 +83,7 @@ proc prePass*(c: PContext; n: PNode) =
                 let feature = parseEnum[Feature](name.strVal)
                 if feature == codeReordering:
                   c.features.incl feature
-                  c.module.incl sfReorder
+                  c.module.flags.incl sfReorder
               except ValueError:
                 discard
             else:
@@ -150,8 +131,6 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
         nil
     of SemPass:
       nil
-    of NifgenPass:
-      setupNifgen(graph, module, idgen)
     of NonePass:
       raiseAssert "use setPipeLinePass to set a proper PipelinePass"
 
@@ -165,11 +144,6 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
   else:
     s = stream
     graph.interactive = stream.kind == llsStdIn
-  var topLevelStmts =
-    if optCompress in graph.config.globalOptions or graph.config.cmd == cmdM:
-      newNodeI(nkStmtList, module.info)
-    else:
-      nil
   while true:
     syntaxes.openParser(p, fileIdx, s, graph.cache, graph.config)
 
@@ -179,8 +153,8 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
       # in ROD files. I think we should enable this feature only
       # for the interactive mode.
       if module.name.s != "nimscriptapi":
-        processImplicitImports graph, graph.config.implicitImports, nkImportStmt, module, ctx, bModule, idgen, topLevelStmts
-        processImplicitImports graph, graph.config.implicitIncludes, nkIncludeStmt, module, ctx, bModule, idgen, topLevelStmts
+        processImplicitImports graph, graph.config.implicitImports, nkImportStmt, module, ctx, bModule, idgen
+        processImplicitImports graph, graph.config.implicitIncludes, nkIncludeStmt, module, ctx, bModule, idgen
 
     checkFirstLineIndentation(p)
     block processCode:
@@ -201,9 +175,7 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
       if graph.pipelinePass != EvalPass:
         message(graph.config, sl.info, hintProcessingStmt, $idgen[])
       var semNode = semWithPContext(ctx, sl)
-      let top = processPipeline(graph, semNode, bModule)
-      if top != nil and topLevelStmts != nil:
-        topLevelStmts.add top
+      discard processPipeline(graph, semNode, bModule)
 
     closeParser(p)
     if s.kind != llsStdIn: break
@@ -220,7 +192,7 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
           if retTyp != nil:
             # TODO: properly semcheck the code of dispatcher?
             createTypeBoundOps(graph, ctx, retTyp, disp.ast.info, idgen)
-          genProcLvl3(m, disp)
+          genProcAux(m, disp)
         discard closePContext(graph, ctx, nil)
   of JSgenPass:
     when not defined(leanCompiler):
@@ -235,66 +207,13 @@ proc processPipelineModule*(graph: ModuleGraph; module: PSym; idgen: IdGenerator
   of Docgen2JsonPass:
     when not defined(leanCompiler):
       discard closeJson(graph, bModule, finalNode)
-  of NifgenPass:
-    closeNif(graph, bModule, finalNode)
   of NonePass:
     raiseAssert "use setPipeLinePass to set a proper PipelinePass"
 
-  when not defined(nimKochBootstrap):
-    if (optCompress in graph.config.globalOptions or graph.config.cmd == cmdM) and
-       not graph.config.isDefined("nimscript"):
-      topLevelStmts.add finalNode
-      # Collect replay actions from both pragma computations and VM state diff
-      var replayActions: seq[PNode] = @[]
-      # Get pragma-recorded replay actions (compile, link, passC, passL, etc.)
-      if graph.nifReplayActions.hasKey(module.position.int32):
-        replayActions.add graph.nifReplayActions[module.position.int32]
-      # Also get VM state diff (macro cache operations)
-      if graph.vm != nil:
-        for (m, n) in PCtx(graph.vm).vmstateDiff:
-          if m == module:
-            replayActions.add n
-      # Collect hooks from the module graph for the current module
-      var hooks = default array[AttachedOp, seq[HookIndexEntry]]
-      for op in TTypeAttachedOp:
-        if op == attachedDeepCopy: continue  # Not supported in nimony
-        let nimonyOp = toAttachedOp(op)
-        for typeId, lazySym in graph.attachedOps[op]:
-          if typeId.module == module.position.int32:
-            let sym = lazySym.sym
-            if sym != nil:
-              hooks[nimonyOp].add toHookIndexEntry(graph.config, typeId, sym)
-      # Collect converters from the module's interface
-      var converters: seq[(nifstreams.SymId, nifstreams.SymId)] = @[]
-      for lazySym in graph.ifaces[module.position].converters:
-        let sym = lazySym.sym
-        if sym != nil:
-          let entry = toConverterIndexEntry(graph.config, sym)
-          if entry[0] != nifstreams.SymId(0):
-            converters.add entry
-      # Collect methods per type for classes
-      var classes: seq[ClassIndexEntry] = @[]
-      for typeId, methodList in graph.methodsPerType:
-        if typeId.module == module.position.int32:
-          var methods: seq[MethodIndexEntry] = @[]
-          for lazySym in methodList:
-            let sym = lazySym.sym
-            if sym != nil:
-              # Generate a method signature (simplified - name and param count)
-              let sig = sym.name.s & "/" & $sym.typImpl.sonsImpl.len
-              methods.add toMethodIndexEntry(graph.config, sym, sig)
-          if methods.len > 0:
-            classes.add ClassIndexEntry(
-              cls: toClassSymId(graph.config, typeId),
-              methods: methods
-            )
-      writeNifModule(graph.config, module.position.int32, topLevelStmts, hooks, converters, classes, replayActions)
-
-  if graph.config.backend notin {backendC, backendCpp, backendObjc} and graph.config.cmd != cmdM:
+  if graph.config.backend notin {backendC, backendCpp, backendObjc}:
     # We only write rod files here if no C-like backend is active.
     # The C-like backends have been patched to support the IC mechanism.
     # They are responsible for closing the rod files. See `cbackend.nim`.
-    # cmdM uses NIF files only, not ROD files.
     closeRodFile(graph, module)
   result = true
 
@@ -312,53 +231,33 @@ proc compilePipelineModule*(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymF
     discard processPipelineModule(graph, result, idGeneratorFromModule(result), s)
   if result == nil:
     var cachedModules: seq[FileIndex] = @[]
-    when not defined(nimKochBootstrap):
-      # For cmdM: load imports from NIF files (but compile the main module from source)
-      # Skip when withinSystem is true (compiling system.nim itself)
-      if graph.config.cmd == cmdM and
-         sfMainModule notin flags and
-         not graph.withinSystem and
-         not graph.config.isDefined("nimscript"):
-        result = moduleFromNifFile(graph, fileIdx, cachedModules)
-        if result == nil:
-          let nifPath = toNifFilename(graph.config, fileIdx)
-          localError(graph.config, unknownLineInfo,
-            "nim m requires precompiled NIF for import: " & toFullPath(graph.config, fileIdx) &
-            " (expected: " & nifPath & ")")
-          return nil  # Don't fall through to compile from source
-    if result == nil and graph.config.cmd != cmdM:
-      # Fall back to ROD file loading (not used for cmdM which uses NIF only)
-      result = moduleFromRodFile(graph, fileIdx, cachedModules)
+    result = moduleFromRodFile(graph, fileIdx, cachedModules)
     let path = toFullPath(graph.config, fileIdx)
     let filename = AbsoluteFile path
-    # it could be a stdinfile/cmdfile
-    if fileExists(filename) and not graph.config.projectIsStdin:
+    if fileExists(filename): # it could be a stdinfile
       graph.cachedFiles[path] = $secureHashFile(path)
     if result == nil:
       result = newModule(graph, fileIdx)
-      result.incl flags
+      result.flags.incl flags
       registerModule(graph, result)
       processModuleAux("import")
     else:
       if sfSystemModule in flags:
         graph.systemModule = result
       if sfMainModule in flags and graph.config.cmd == cmdM:
-        result.incl flags
+        result.flags.incl flags
         registerModule(graph, result)
         processModuleAux("import")
       partialInitModule(result, graph, fileIdx, filename)
     for m in cachedModules:
       registerModuleById(graph, m)
-      if graph.config.cmd == cmdM:
-        # cmdM uses NIF files - replay from module AST loaded by loadNifModule
-        let module = graph.getModule(m)
-        if module != nil and module.ast != nil:
-          replayStateChanges(module, graph)
+      if sfMainModule in flags and graph.config.cmd == cmdM:
+        discard
       else:
         replayStateChanges(graph.packed.pm[m.int].module, graph)
         replayGenericCacheInformation(graph, m.int)
   elif graph.isDirty(result):
-    result.excl sfDirty
+    result.flags.excl sfDirty
     # reset module fields:
     initStrTables(graph, result)
     result.ast = nil
@@ -386,12 +285,10 @@ proc connectPipelineCallbacks*(graph: ModuleGraph) =
 
 proc compilePipelineSystemModule*(graph: ModuleGraph) =
   if graph.systemModule == nil:
-    graph.withinSystem = true
     connectPipelineCallbacks(graph)
     graph.config.m.systemFileIdx = fileInfoIdx(graph.config,
         graph.config.libpath / RelativeFile"system.nim")
     discard graph.compilePipelineModule(graph.config.m.systemFileIdx, {sfSystemModule})
-    graph.withinSystem = false
 
 proc compilePipelineProject*(graph: ModuleGraph; projectFileIdx = InvalidFileIdx) =
   connectPipelineCallbacks(graph)
@@ -408,23 +305,7 @@ proc compilePipelineProject*(graph: ModuleGraph; projectFileIdx = InvalidFileIdx
   graph.importStack.add projectFile
 
   if projectFile == systemFileIdx:
-    graph.withinSystem = true
     discard graph.compilePipelineModule(projectFile, {sfMainModule, sfSystemModule})
-    graph.withinSystem = false
-  elif graph.config.cmd == cmdM:
-    # For cmdM: load system.nim from NIF first, then compile the main module
-    connectPipelineCallbacks(graph)
-    graph.config.m.systemFileIdx = fileInfoIdx(graph.config,
-        graph.config.libpath / RelativeFile"system.nim")
-    var cachedModules: seq[FileIndex] = @[]
-    when not defined(nimKochBootstrap):
-      graph.systemModule = moduleFromNifFile(graph, graph.config.m.systemFileIdx, cachedModules)
-      if graph.systemModule == nil:
-        let nifPath = toNifFilename(graph.config, graph.config.m.systemFileIdx)
-        localError(graph.config, unknownLineInfo,
-          "nim m requires precompiled NIF for system module (expected: " & nifPath & ")")
-        return
-    discard graph.compilePipelineModule(projectFile, {sfMainModule})
   else:
     graph.compilePipelineSystemModule()
     discard graph.compilePipelineModule(projectFile, {sfMainModule})

compiler/platform.nim

@@ -210,8 +210,8 @@ type
     cpuNone, cpuI386, cpuM68k, cpuAlpha, cpuPowerpc, cpuPowerpc64,
     cpuPowerpc64el, cpuSparc, cpuVm, cpuHppa, cpuIa64, cpuAmd64, cpuMips,
     cpuMipsel, cpuArm, cpuArm64, cpuJS, cpuNimVM, cpuAVR, cpuMSP430,
-    cpuSparc64, cpuS390x, cpuMips64, cpuMips64el, cpuRiscV32, cpuRiscV64,
-    cpuEsp, cpuWasm32, cpuE2k, cpuLoongArch64
+    cpuSparc64, cpuMips64, cpuMips64el, cpuRiscV32, cpuRiscV64, cpuEsp, cpuWasm32,
+    cpuE2k, cpuLoongArch64
 
 type
   TInfoCPU* = tuple[name: string, intSize: int, endian: Endianness,
@@ -241,7 +241,6 @@ const
     (name: "avr", intSize: 16, endian: littleEndian, floatSize: 32, bit: 16),
     (name: "msp430", intSize: 16, endian: littleEndian, floatSize: 32, bit: 16),
     (name: "sparc64", intSize: 64, endian: bigEndian, floatSize: 64, bit: 64),
-    (name: "s390x", intSize: 64, endian: bigEndian, floatSize: 64, bit: 64),
     (name: "mips64", intSize: 64, endian: bigEndian, floatSize: 64, bit: 64),
     (name: "mips64el", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64),
     (name: "riscv32", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),

compiler/plugins/itersgen.nim

@@ -33,7 +33,7 @@ proc iterToProcImpl*(c: PContext, n: PNode): PNode =
 
   let prc = newSym(skProc, n[3].ident, c.idgen, iter.sym.owner, iter.sym.info)
   prc.typ = copyType(iter.sym.typ, c.idgen, prc)
-  excl prc.typ, tfCapturesEnv
+  excl prc.typ.flags, tfCapturesEnv
   prc.typ.n.add newSymNode(getEnvParam(iter.sym))
   prc.typ.rawAddSon t
   let orig = iter.sym.ast

compiler/pragmas.nim

@@ -107,7 +107,7 @@ proc getPragmaVal*(procAst: PNode; name: TSpecialWord): PNode =
       return it[1]
 
 proc pragma*(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
-            isStatement: bool = false; comesFromPush = false)
+            isStatement: bool = false)
 
 proc recordPragma(c: PContext; n: PNode; args: varargs[string]) =
   var recorded = newNodeI(nkReplayAction, n.info)
@@ -148,7 +148,7 @@ proc pragmaEnsures(c: PContext, n: PNode) =
     if o.kind in routineKinds and o.typ != nil and o.typ.returnType != nil:
       var s = newSym(skResult, getIdent(c.cache, "result"), c.idgen, o, n.info)
       s.typ = o.typ.returnType
-      incl(s.flagsImpl, sfUsed)
+      incl(s.flags, sfUsed)
       addDecl(c, s)
     n[1] = c.semExpr(c, n[1])
     closeScope(c)
@@ -156,12 +156,12 @@ proc pragmaEnsures(c: PContext, n: PNode) =
 proc setExternName(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   # special cases to improve performance:
   if extname == "$1":
-    s.setSnippet(rope(s.name.s))
+    s.loc.snippet = rope(s.name.s)
   elif '$' notin extname:
-    s.setSnippet(rope(extname))
+    s.loc.snippet = rope(extname)
   else:
     try:
-      s.setSnippet(rope(extname % s.name.s))
+      s.loc.snippet = rope(extname % s.name.s)
     except ValueError:
       localError(c.config, info, "invalid extern name: '" & extname & "'. (Forgot to escape '$'?)")
   when hasFFI:
@@ -170,36 +170,36 @@ proc setExternName(c: PContext; s: PSym, extname: string, info: TLineInfo) =
 
 proc makeExternImport(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   setExternName(c, s, extname, info)
-  s.incl(sfImportc)
-  s.excl(sfForward)
+  incl(s.flags, sfImportc)
+  excl(s.flags, sfForward)
 
 proc makeExternExport(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   setExternName(c, s, extname, info)
-  s.incl(sfExportc)
+  incl(s.flags, sfExportc)
 
 proc processImportCompilerProc(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   setExternName(c, s, extname, info)
-  s.incl(sfImportc)
-  s.excl(sfForward)
-  incl(s.locImpl.flags, lfImportCompilerProc)
+  incl(s.flags, sfImportc)
+  excl(s.flags, sfForward)
+  incl(s.loc.flags, lfImportCompilerProc)
 
 proc processImportCpp(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   setExternName(c, s, extname, info)
-  s.incl(sfImportc)
-  incl(s.flagsImpl, sfInfixCall)
-  excl(s.flagsImpl, sfForward)
+  incl(s.flags, sfImportc)
+  incl(s.flags, sfInfixCall)
+  excl(s.flags, sfForward)
   if c.config.backend == backendC:
     let m = s.getModule()
-    incl(m.flagsImpl, sfCompileToCpp)
+    incl(m.flags, sfCompileToCpp)
   incl c.config.globalOptions, optMixedMode
 
 proc processImportObjC(c: PContext; s: PSym, extname: string, info: TLineInfo) =
   setExternName(c, s, extname, info)
-  s.incl(sfImportc)
-  incl(s.flagsImpl, sfNamedParamCall)
-  excl(s.flagsImpl, sfForward)
+  incl(s.flags, sfImportc)
+  incl(s.flags, sfNamedParamCall)
+  excl(s.flags, sfForward)
   let m = s.getModule()
-  m.incl(sfCompileToObjc)
+  incl(m.flags, sfCompileToObjc)
 
 proc newEmptyStrNode(c: PContext; n: PNode, strVal: string = ""): PNode {.noinline.} =
   result = newNodeIT(nkStrLit, n.info, getSysType(c.graph, n.info, tyString))
@@ -239,14 +239,14 @@ proc getOptionalStr(c: PContext, n: PNode, defaultStr: string): string =
 proc processVirtual(c: PContext, n: PNode, s: PSym, flag: TSymFlag) =
   s.constraint = newEmptyStrNode(c, n, getOptionalStr(c, n, "$1"))
   s.constraint.strVal = s.constraint.strVal % s.name.s
-  s.flagsImpl.incl {flag, sfInfixCall, sfExportc, sfMangleCpp}
+  s.flags.incl {flag, sfInfixCall, sfExportc, sfMangleCpp}
 
   s.typ.callConv = ccMember
   incl c.config.globalOptions, optMixedMode
 
 proc processCodegenDecl(c: PContext, n: PNode, sym: PSym) =
   sym.constraint = getStrLitNode(c, n)
-  sym.flagsImpl.incl sfCodegenDecl
+  sym.flags.incl sfCodegenDecl
 
 proc processMagic(c: PContext, n: PNode, s: PSym) =
   #if sfSystemModule notin c.module.flags:
@@ -282,10 +282,10 @@ proc onOff(c: PContext, n: PNode, op: TOptions, resOptions: var TOptions) =
 
 proc pragmaNoForward*(c: PContext, n: PNode; flag=sfNoForward) =
   if isTurnedOn(c, n):
-    incl(c.module.flagsImpl, flag)
+    incl(c.module.flags, flag)
     c.features.incl codeReordering
   else:
-    excl(c.module.flagsImpl, flag)
+    excl(c.module.flags, flag)
     # c.features.excl codeReordering
 
   # deprecated as of 0.18.1
@@ -357,9 +357,9 @@ proc processDynLib(c: PContext, n: PNode, sym: PSym) =
       var lib = getLib(c, libDynamic, expectDynlibNode(c, n))
       if not lib.isOverridden:
         addToLib(lib, sym)
-        sym.incl(lfDynamicLib)
+        incl(sym.loc.flags, lfDynamicLib)
     else:
-      sym.incl(lfExportLib)
+      incl(sym.loc.flags, lfExportLib)
     # since we'll be loading the dynlib symbols dynamically, we must use
     # a calling convention that doesn't introduce custom name mangling
     # cdecl is the default - the user can override this explicitly
@@ -435,7 +435,7 @@ proc processExperimental(c: PContext; n: PNode) =
           if not isTopLevel(c):
               localError(c.config, n.info,
                          "Code reordering experimental pragma only valid at toplevel")
-          c.module.flagsImpl.incl sfReorder
+          c.module.flags.incl sfReorder
       except ValueError:
         localError(c.config, n[1].info, "unknown experimental feature")
     else:
@@ -590,7 +590,7 @@ proc processCompile(c: PContext, n: PNode) =
     var customArgs = ""
     if n.kind in nkCallKinds:
       s = getStrLit(c, n, 1)
-      if n.len == 3:
+      if n.len <= 3:
         customArgs = getStrLit(c, n, 2)
       else:
         localError(c.config, n.info, "'.compile' pragma takes up 2 arguments")
@@ -636,11 +636,8 @@ proc semAsmOrEmit*(con: PContext, n: PNode, marker: char): PNode =
         var e = searchInScopes(con, getIdent(con.cache, sub), amb)
         # XXX what to do here if 'amb' is true?
         if e != nil:
-          incl(e.flagsImpl, sfUsed)
-          if isDefined(con.config, "nimPreviewAsmSemSymbol"):
-            result.add con.semExprWithType(con, newSymNode(e), {efTypeAllowed})
-          else:
-            result.add newSymNode(e)
+          incl(e.flags, sfUsed)
+          result.add newSymNode(e)
         else:
           result.add newStrNode(nkStrLit, sub)
       else:
@@ -725,12 +722,12 @@ proc processPragma(c: PContext, n: PNode, i: int) =
 proc pragmaRaisesOrTags(c: PContext, n: PNode) =
   proc processExc(c: PContext, x: PNode) =
     if c.hasUnresolvedArgs(c, x):
-      x.typ = makeTypeFromExpr(c, x)
+      x.typ() = makeTypeFromExpr(c, x)
     else:
       var t = skipTypes(c.semTypeNode(c, x, nil), skipPtrs)
       if t.kind notin {tyObject, tyOr}:
         localError(c.config, x.info, errGenerated, "invalid type for raises/tags list")
-      x.typ = t
+      x.typ() = t
 
   if n.kind in nkPragmaCallKinds and n.len == 2:
     let it = n[1]
@@ -757,15 +754,15 @@ proc typeBorrow(c: PContext; sym: PSym, n: PNode) =
     let it = n[1]
     if it.kind != nkAccQuoted:
       localError(c.config, n.info, "a type can only borrow `.` for now")
-  incl(sym.typ, tfBorrowDot)
+  incl(sym.typ.flags, tfBorrowDot)
 
 proc markCompilerProc(c: PContext; s: PSym) =
   # minor hack ahead: FlowVar is the only generic .compilerproc type which
   # should not have an external name set:
   if s.kind != skType or s.name.s != "FlowVar":
     makeExternExport(c, s, "$1", s.info)
-  incl(s, sfCompilerProc)
-  incl(s.flagsImpl, sfUsed)
+  incl(s.flags, sfCompilerProc)
+  incl(s.flags, sfUsed)
   registerCompilerProc(c.graph, s)
   if c.config.symbolFiles != disabledSf:
     addCompilerProc(c.encoder, c.packedRepr, s)
@@ -773,7 +770,7 @@ proc markCompilerProc(c: PContext; s: PSym) =
 proc deprecatedStmt(c: PContext; outerPragma: PNode) =
   let pragma = outerPragma[1]
   if pragma.kind in {nkStrLit..nkTripleStrLit}:
-    incl(c.module, sfDeprecated)
+    incl(c.module.flags, sfDeprecated)
     c.module.constraint = getStrLitNode(c, outerPragma)
     return
   if pragma.kind != nkBracket:
@@ -842,7 +839,7 @@ proc processEffectsOf(c: PContext, n: PNode; owner: PSym) =
     let r = c.semExpr(c, n)
     if r.kind == nkSym and r.sym.kind == skParam:
       if r.sym.owner == owner:
-        incl r.sym, sfEffectsDelayed
+        incl r.sym.flags, sfEffectsDelayed
       else:
         localError(c.config, n.info, errGenerated, "parameter cannot be declared as .effectsOf")
     else:
@@ -893,7 +890,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
     if keyDeep:
       localError(c.config, it.info, "user pragma cannot have arguments")
 
-    pragma(c, sym, userPragma.ast, validPragmas, isStatement, comesFromPush)
+    pragma(c, sym, userPragma.ast, validPragmas, isStatement)
     n.sons[i..i] = userPragma.ast.sons # expand user pragma with its content
     i.inc(userPragma.ast.len - 1) # inc by -1 is ok, user pragmas was empty
   else:
@@ -907,8 +904,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
           if c.config.backend != backendCpp:
             localError(c.config, it.info, "exportcpp requires `cpp` backend, got: " & $c.config.backend)
           else:
-            incl(sym, sfMangleCpp)
-        incl(sym.flagsImpl, sfUsed) # avoid wrong hints
+            incl(sym.flags, sfMangleCpp)
+        incl(sym.flags, sfUsed) # avoid wrong hints
       of wImportc:
         let name = getOptionalStr(c, it, "$1")
         cppDefine(c.config, name)
@@ -921,24 +918,24 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         processImportCompilerProc(c, sym, name, it.info)
       of wExtern: setExternName(c, sym, expectStrLit(c, it), it.info)
       of wDirty:
-        if sym.kind == skTemplate: incl(sym, sfDirty)
+        if sym.kind == skTemplate: incl(sym.flags, sfDirty)
         else: invalidPragma(c, it)
       of wRedefine:
-        if sym.kind == skTemplate: incl(sym, sfTemplateRedefinition)
+        if sym.kind == skTemplate: incl(sym.flags, sfTemplateRedefinition)
         else: invalidPragma(c, it)
       of wCallsite:
-        if sym.kind == skTemplate: incl(sym, sfCallsite)
+        if sym.kind == skTemplate: incl(sym.flags, sfCallsite)
         else: invalidPragma(c, it)
       of wImportCpp:
         processImportCpp(c, sym, getOptionalStr(c, it, "$1"), it.info)
       of wCppNonPod:
-        incl(sym, sfCppNonPod)
+        incl(sym.flags, sfCppNonPod)
       of wImportJs:
         if c.config.backend != backendJs:
           localError(c.config, it.info, "`importjs` pragma requires the JavaScript target")
         let name = getOptionalStr(c, it, "$1")
-        incl(sym, sfImportc)
-        incl(sym.flagsImpl, sfInfixCall)
+        incl(sym.flags, sfImportc)
+        incl(sym.flags, sfInfixCall)
         if sym.kind in skProcKinds and {'(', '#', '@'} notin name:
           localError(c.config, n.info, "`importjs` for routines requires a pattern")
         setExternName(c, sym, name, it.info)
@@ -947,19 +944,15 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
       of wSize:
         if sym.typ == nil: invalidPragma(c, it)
         var size = expectIntLit(c, it)
-        if sfImportc in sym.flags:
-          # no restrictions on size for imported types
-          setImportedTypeSize(c.config, sym.typ, size)
+        case size
+        of 1, 2, 4:
+          sym.typ.size = size
+          sym.typ.align = int16 size
+        of 8:
+          sym.typ.size = 8
+          sym.typ.align = floatInt64Align(c.config)
         else:
-          case size
-          of 1, 2, 4:
-            sym.typ.size = size
-            sym.typ.align = int16 size
-          of 8:
-            sym.typ.size = 8
-            sym.typ.align = floatInt64Align(c.config)
-          else:
-            localError(c.config, it.info, "size may only be 1, 2, 4 or 8")
+          localError(c.config, it.info, "size may only be 1, 2, 4 or 8")
       of wAlign:
         let alignment = expectIntLit(c, it)
         if isPowerOfTwo(alignment) and alignment > 0:
@@ -968,29 +961,29 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
           localError(c.config, it.info, "power of two expected")
       of wNodecl:
         noVal(c, it)
-        sym.incl(lfNoDecl)
+        incl(sym.loc.flags, lfNoDecl)
       of wPure, wAsmNoStackFrame:
         noVal(c, it)
         if sym != nil:
           if k == wPure and sym.kind in routineKinds: invalidPragma(c, it)
-          else: incl(sym, sfPure)
+          else: incl(sym.flags, sfPure)
       of wVolatile:
         noVal(c, it)
-        incl(sym, sfVolatile)
+        incl(sym.flags, sfVolatile)
       of wCursor:
         noVal(c, it)
-        incl(sym, sfCursor)
+        incl(sym.flags, sfCursor)
       of wRegister:
         noVal(c, it)
-        incl(sym, sfRegister)
+        incl(sym.flags, sfRegister)
       of wNoalias:
         noVal(c, it)
-        incl(sym, sfNoalias)
+        incl(sym.flags, sfNoalias)
       of wEffectsOf:
         processEffectsOf(c, it, sym)
       of wThreadVar:
         noVal(c, it)
-        incl(sym, {sfThread, sfGlobal})
+        incl(sym.flags, {sfThread, sfGlobal})
       of wDeadCodeElimUnused:
         warningDeprecated(c.config, n.info, "'{.deadcodeelim: on.}' is deprecated, now a noop")  # deprecated, dead code elim always on
       of wNoForward: pragmaNoForward(c, it)
@@ -1000,50 +993,51 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         noVal(c, it)
         if comesFromPush:
           if sym.kind in {skProc, skFunc}:
-            incl(sym, sfCompileTime)
+            incl(sym.flags, sfCompileTime)
         else:
-          incl(sym, sfCompileTime)
+          incl(sym.flags, sfCompileTime)
         #incl(sym.loc.flags, lfNoDecl)
       of wGlobal:
         noVal(c, it)
-        incl(sym, {sfGlobal, sfPure})
+        incl(sym.flags, sfGlobal)
+        incl(sym.flags, sfPure)
       of wConstructor:
-        incl(sym, sfConstructor)
+        incl(sym.flags, sfConstructor)
         if sfImportc notin sym.flags:
           sym.constraint = newEmptyStrNode(c, it, getOptionalStr(c, it, ""))
           sym.constraint.strVal = sym.constraint.strVal
-          sym.flagsImpl.incl {sfExportc, sfMangleCpp}
+          sym.flags.incl {sfExportc, sfMangleCpp}
           sym.typ.callConv = ccNoConvention
       of wHeader:
         var lib = getLib(c, libHeader, getStrLitNode(c, it))
         addToLib(lib, sym)
-        incl(sym, sfImportc)
-        incl(sym.locImpl.flags, lfHeader)
-        incl(sym.locImpl.flags, lfNoDecl)
+        incl(sym.flags, sfImportc)
+        incl(sym.loc.flags, lfHeader)
+        incl(sym.loc.flags, lfNoDecl)
         # implies nodecl, because otherwise header would not make sense
-        if sym.locImpl.snippet == "": sym.locImpl.snippet = rope(sym.name.s)
+        if sym.loc.snippet == "": sym.loc.snippet = rope(sym.name.s)
       of wNoSideEffect:
         noVal(c, it)
         if sym != nil:
-          incl(sym, sfNoSideEffect)
-          if sym.typ != nil: incl(sym.typ, tfNoSideEffect)
+          incl(sym.flags, sfNoSideEffect)
+          if sym.typ != nil: incl(sym.typ.flags, tfNoSideEffect)
       of wSideEffect:
         noVal(c, it)
-        incl(sym, sfSideEffect)
+        incl(sym.flags, sfSideEffect)
       of wNoreturn:
         noVal(c, it)
         # Disable the 'noreturn' annotation when in the "Quirky Exceptions" mode!
         if c.config.exc != excQuirky:
-          incl(sym, sfNoReturn)
+          incl(sym.flags, sfNoReturn)
         if sym.typ.returnType != nil:
           localError(c.config, sym.ast[paramsPos][0].info,
             ".noreturn with return type not allowed")
       of wNoDestroy:
         noVal(c, it)
-        incl(sym, sfGeneratedOp)
+        incl(sym.flags, sfGeneratedOp)
       of wNosinks:
         noVal(c, it)
-        incl(sym, sfWasForwarded)
+        incl(sym.flags, sfWasForwarded)
       of wDynlib:
         processDynLib(c, it, sym)
       of wCompilerProc, wCore:
@@ -1052,79 +1046,79 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         recordPragma(c, it, "cppdefine", sym.name.s)
         if sfFromGeneric notin sym.flags: markCompilerProc(c, sym)
       of wNonReloadable:
-        sym.incl sfNonReloadable
+        sym.flags.incl sfNonReloadable
       of wProcVar:
         # old procvar annotation, no longer needed
         noVal(c, it)
       of wExplain:
-        sym.incl sfExplain
+        sym.flags.incl sfExplain
       of wDeprecated:
         if sym != nil and sym.kind in routineKinds + {skType, skVar, skLet, skConst}:
           if it.kind in nkPragmaCallKinds: discard getStrLitNode(c, it)
-          incl(sym, sfDeprecated)
+          incl(sym.flags, sfDeprecated)
         elif sym != nil and sym.kind != skModule:
           # We don't support the extra annotation field
           if it.kind in nkPragmaCallKinds:
             localError(c.config, it.info, "annotation to deprecated not supported here")
-          incl(sym, sfDeprecated)
+          incl(sym.flags, sfDeprecated)
         # At this point we're quite sure this is a statement and applies to the
         # whole module
         elif it.kind in nkPragmaCallKinds: deprecatedStmt(c, it)
-        else: incl(c.module, sfDeprecated)
+        else: incl(c.module.flags, sfDeprecated)
       of wVarargs:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfVarargs)
+        else: incl(sym.typ.flags, tfVarargs)
       of wBorrow:
         if sym.kind == skType:
           typeBorrow(c, sym, it)
         else:
           noVal(c, it)
-          incl(sym, sfBorrow)
+          incl(sym.flags, sfBorrow)
       of wFinal:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfFinal)
+        else: incl(sym.typ.flags, tfFinal)
       of wInheritable:
         noVal(c, it)
         if sym.typ == nil or tfFinal in sym.typ.flags: invalidPragma(c, it)
-        else: incl(sym.typ, tfInheritable)
+        else: incl(sym.typ.flags, tfInheritable)
       of wPackage:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym, sfForward)
+        else: incl(sym.flags, sfForward)
       of wAcyclic:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfAcyclic)
+        else: incl(sym.typ.flags, tfAcyclic)
       of wShallow:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfShallow)
+        else: incl(sym.typ.flags, tfShallow)
       of wThread:
         noVal(c, it)
-        incl(sym, sfThread)
+        incl(sym.flags, sfThread)
         if sym.typ != nil:
-          incl(sym.typ, tfThread)
+          incl(sym.typ.flags, tfThread)
           if sym.typ.callConv == ccClosure: sym.typ.callConv = ccNimCall
       of wSendable:
         noVal(c, it)
         if sym != nil and sym.typ != nil:
-          incl(sym.typ, tfSendable)
+          incl(sym.typ.flags, tfSendable)
         else:
           invalidPragma(c, it)
       of wGcSafe:
         noVal(c, it)
         if sym != nil:
-          if sym.kind != skType: incl(sym, sfThread)
-          if sym.typ != nil: incl(sym.typ, tfGcSafe)
+          if sym.kind != skType: incl(sym.flags, sfThread)
+          if sym.typ != nil: incl(sym.typ.flags, tfGcSafe)
           else: invalidPragma(c, it)
         else:
           discard "no checking if used as a code block"
       of wPacked:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfPacked)
+        else: incl(sym.typ.flags, tfPacked)
       of wHint:
         let s = expectStrLit(c, it)
         recordPragma(c, it, "hint", s)
@@ -1140,8 +1134,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
           # distinguish properly between
           # ``proc p() {.error}`` and ``proc p() = {.error: "msg".}``
           if it.kind in nkPragmaCallKinds: discard getStrLitNode(c, it)
-          incl(sym, sfError)
-          excl(sym, sfForward)
+          incl(sym.flags, sfError)
+          excl(sym.flags, sfForward)
         else:
           let s = expectStrLit(c, it)
           recordPragma(c, it, "error", s)
@@ -1151,18 +1145,18 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
       of wUndef: processUndef(c, it)
       of wCompile:
         let m = sym.getModule()
-        incl(m.flagsImpl, sfUsed)
+        incl(m.flags, sfUsed)
         processCompile(c, it)
       of wLink: processLink(c, it)
       of wPassl:
         let m = sym.getModule()
-        incl(m.flagsImpl, sfUsed)
+        incl(m.flags, sfUsed)
         let s = expectStrLit(c, it)
         extccomp.addLinkOption(c.config, s)
         recordPragma(c, it, "passl", s)
       of wPassc:
         let m = sym.getModule()
-        incl(m.flagsImpl, sfUsed)
+        incl(m.flags, sfUsed)
         let s = expectStrLit(c, it)
         extccomp.addCompileOption(c.config, s)
         recordPragma(c, it, "passc", s)
@@ -1180,16 +1174,16 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         result = true
       of wPragma:
         if not sym.isNil and sym.kind == skTemplate:
-          sym.incl sfCustomPragma
+          sym.flags.incl sfCustomPragma
         else:
           processPragma(c, n, i)
           result = true
       of wDiscardable:
         noVal(c, it)
-        if sym != nil: incl(sym, sfDiscardable)
+        if sym != nil: incl(sym.flags, sfDiscardable)
       of wNoInit:
         noVal(c, it)
-        if sym != nil: incl(sym, sfNoInit)
+        if sym != nil: incl(sym.flags, sfNoInit)
       of wCodegenDecl: processCodegenDecl(c, it, sym)
       of wChecks, wObjChecks, wFieldChecks, wRangeChecks, wBoundChecks,
          wOverflowChecks, wNilChecks, wAssertions, wWarnings, wHints,
@@ -1199,8 +1193,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         processOption(c, it, c.config.options)
       of wStackTrace, wLineTrace:
         if sym.kind in {skProc, skMethod, skConverter}:
-          ensureMutable sym
-          processOption(c, it, sym.optionsImpl)
+          processOption(c, it, sym.options)
         else:
           processOption(c, it, c.config.options)
       of FirstCallConv..LastCallConv:
@@ -1208,7 +1201,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         if sym.typ == nil: invalidPragma(c, it)
         else:
           sym.typ.callConv = wordToCallConv(k)
-          sym.typ.incl tfExplicitCallConv
+          sym.typ.flags.incl tfExplicitCallConv
       of wEmit: pragmaEmit(c, it)
       of wUnroll: pragmaUnroll(c, it)
       of wLinearScanEnd, wComputedGoto: noVal(c, it)
@@ -1218,11 +1211,11 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
       of wIncompleteStruct:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfIncompleteStruct)
+        else: incl(sym.typ.flags, tfIncompleteStruct)
       of wCompleteStruct:
         noVal(c, it)
         if sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfCompleteStruct)
+        else: incl(sym.typ.flags, tfCompleteStruct)
       of wUnchecked:
         noVal(c, it)
         if sym.typ == nil or sym.typ.kind notin {tyArray, tyUncheckedArray}:
@@ -1235,35 +1228,34 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         else:
           noVal(c, it)
           if sym.typ == nil: invalidPragma(c, it)
-          else: incl(sym.typ, tfUnion)
+          else: incl(sym.typ.flags, tfUnion)
       of wRequiresInit:
         noVal(c, it)
         if sym.kind == skField:
-          sym.incl sfRequiresInit
+          sym.flags.incl sfRequiresInit
         elif sym.typ != nil:
-          incl(sym.typ, tfNeedsFullInit)
+          incl(sym.typ.flags, tfNeedsFullInit)
         else:
           invalidPragma(c, it)
       of wByRef:
         noVal(c, it)
         if sym != nil and sym.kind == skParam:
-          ensureMutable sym
-          sym.optionsImpl.incl optByRef
+          sym.options.incl optByRef
         elif sym == nil or sym.typ == nil:
           processOption(c, it, c.config.options)
         else:
-          incl(sym.typ, tfByRef)
+          incl(sym.typ.flags, tfByRef)
       of wByCopy:
         noVal(c, it)
         if sym.kind == skParam:
-          incl(sym, sfByCopy)
+          incl(sym.flags, sfByCopy)
         elif sym.kind != skType or sym.typ == nil: invalidPragma(c, it)
-        else: incl(sym.typ, tfByCopy)
+        else: incl(sym.typ.flags, tfByCopy)
       of wPartial:
         noVal(c, it)
         if sym.kind != skType or sym.typ == nil: invalidPragma(c, it)
         else:
-          incl(sym.typ, tfPartial)
+          incl(sym.typ.flags, tfPartial)
       of wInject, wGensym:
         # We check for errors, but do nothing with these pragmas otherwise
         # as they are handled directly in 'evalTemplate'.
@@ -1291,7 +1283,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         if sym == nil or sym.kind notin {skVar, skLet}:
           invalidPragma(c, it)
         else:
-          sym.incl sfGoto
+          sym.flags.incl sfGoto
       of wExportNims:
         if sym == nil: invalidPragma(c, it)
         else: magicsys.registerNimScriptSymbol(c.graph, sym)
@@ -1306,7 +1298,7 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         noVal(c, it)
       of wBase:
         noVal(c, it)
-        sym.incl sfBase
+        sym.flags.incl sfBase
       of wIntDefine:
         processDefineConst(c, n, sym, mIntDefine)
       of wStrDefine:
@@ -1316,22 +1308,17 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
       of wUsed:
         noVal(c, it)
         if sym == nil: invalidPragma(c, it)
-        else: sym.incl sfUsed
+        else: sym.flags.incl sfUsed
       of wLiftLocals:
-        sym.incl(sfForceLift)
+        sym.flags.incl(sfForceLift)
       of wRequires, wInvariant, wAssume, wAssert:
         pragmaProposition(c, it)
       of wEnsures:
         pragmaEnsures(c, it)
-      of wEnforceNoRaises:
-        sym.incl sfNeverRaises
-      of wQuirky:
-        sym.incl sfNeverRaises
-        if sym.kind in {skProc, skMethod, skConverter, skFunc, skIterator}:
-          ensureMutable sym
-          sym.optionsImpl.incl optQuirky
+      of wEnforceNoRaises, wQuirky:
+        sym.flags.incl sfNeverRaises
       of wSystemRaisesDefect:
-        sym.incl sfSystemRaisesDefect
+        sym.flags.incl sfSystemRaisesDefect
       of wVirtual:
         processVirtual(c, it, sym, sfVirtual)
       of wMember:
@@ -1388,9 +1375,9 @@ proc implicitPragmas*(c: PContext, sym: PSym, info: TLineInfo,
     var lib = c.optionStack[^1].dynlib
     if {lfDynamicLib, lfHeader} * sym.loc.flags == {} and
         sfImportc in sym.flags and lib != nil:
-      incl(sym, lfDynamicLib)
+      incl(sym.loc.flags, lfDynamicLib)
       addToLib(lib, sym)
-      if sym.locImpl.snippet == "": sym.locImpl.snippet = rope(sym.name.s)
+      if sym.loc.snippet == "": sym.loc.snippet = rope(sym.name.s)
 
 proc hasPragma*(n: PNode, pragma: TSpecialWord): bool =
   if n == nil: return false
@@ -1411,12 +1398,11 @@ proc pragmaRec(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
     inc i
 
 proc pragma(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords;
-            isStatement: bool; comesFromPush = false) =
+            isStatement: bool) =
   if n == nil: return
   pragmaRec(c, sym, n, validPragmas, isStatement)
   # XXX: in the case of a callable def, this should use its info
-  if not comesFromPush:
-    implicitPragmas(c, sym, n.info, validPragmas)
+  implicitPragmas(c, sym, n.info, validPragmas)
 
 proc pragmaCallable*(c: PContext, sym: PSym, n: PNode, validPragmas: TSpecialWords,
                     isStatement: bool = false) =

compiler/renderer.nim

@@ -30,7 +30,7 @@ type
   TRenderFlags* = set[TRenderFlag]
   TRenderTok* = object
     kind*: TokType
-    length*: int32
+    length*: int16
     sym*: PSym
 
   Section = enum
@@ -154,7 +154,7 @@ proc initSrcGen(renderFlags: TRenderFlags; config: ConfigRef): TSrcGen =
                    )
 
 proc addTok(g: var TSrcGen, kind: TokType, s: string; sym: PSym = nil) =
-  g.tokens.add TRenderTok(kind: kind, length: int32(s.len), sym: sym)
+  g.tokens.add TRenderTok(kind: kind, length: int16(s.len), sym: sym)
   g.buf.add(s)
   if kind != tkSpaces:
     inc g.col, s.len
@@ -327,10 +327,6 @@ proc pushCom(g: var TSrcGen, n: PNode) =
   setLen(g.comStack, g.comStack.len + 1)
   g.comStack[^1] = n
 
-proc popCom(g: var TSrcGen): PNode =
-  result = g.comStack[^1]
-  setLen(g.comStack, g.comStack.len - 1)
-
 proc popAllComs(g: var TSrcGen) =
   setLen(g.comStack, 0)
 
@@ -414,7 +410,7 @@ proc atom(g: TSrcGen; n: PNode): string =
   of nkEmpty: result = ""
   of nkIdent: result = n.ident.s
   of nkSym: result = n.sym.name.s
-  of nkClosedSymChoice, nkOpenSymChoice, nkOpenSym: result = n[0].sym.name.s
+  of nkClosedSymChoice, nkOpenSymChoice: result = n[0].sym.name.s
   of nkStrLit: result = ""; result.addQuoted(n.strVal)
   of nkRStrLit: result = "r\"" & replace(n.strVal, "\"", "\"\"") & '\"'
   of nkTripleStrLit: result = "\"\"\"" & n.strVal & "\"\"\""
@@ -569,16 +565,8 @@ proc lsub(g: TSrcGen; n: PNode): int =
   of nkIfExpr:
     result = lsub(g, n[0][0]) + lsub(g, n[0][1]) + lsons(g, n, 1) +
         len("if_:_")
-  of nkElifExpr, nkElifBranch:
-    if isEmptyType(n[1].typ):
-      result = lsons(g, n) + len("elif_:_")
-    else:
-      result = lsons(g, n) + len("_elif_:_")
-  of nkElseExpr, nkElse:
-    if isEmptyType(n[0].typ):
-      result = lsub(g, n[0]) + len("else:_")
-    else:
-      result = lsub(g, n[0]) + len("_else:_") # type descriptions
+  of nkElifExpr: result = lsons(g, n) + len("_elif_:_")
+  of nkElseExpr: result = lsub(g, n[0]) + len("_else:_") # type descriptions
   of nkTypeOfExpr: result = (if n.len > 0: lsub(g, n[0]) else: 0)+len("typeof()")
   of nkRefTy: result = (if n.len > 0: lsub(g, n[0])+1 else: 0) + len("ref")
   of nkPtrTy: result = (if n.len > 0: lsub(g, n[0])+1 else: 0) + len("ptr")
@@ -621,6 +609,8 @@ proc lsub(g: TSrcGen; n: PNode): int =
   of nkCommentStmt: result = n.comment.len
   of nkOfBranch: result = lcomma(g, n, 0, - 2) + lsub(g, lastSon(n)) + len("of_:_")
   of nkImportAs: result = lsub(g, n[0]) + len("_as_") + lsub(g, n[1])
+  of nkElifBranch: result = lsons(g, n) + len("elif_:_")
+  of nkElse: result = lsub(g, n[0]) + len("else:_")
   of nkFinally: result = lsub(g, n[0]) + len("finally:_")
   of nkGenericParams: result = lcomma(g, n) + 2
   of nkFormalParams:
@@ -1012,7 +1002,7 @@ type
 proc bracketKind*(g: TSrcGen, n: PNode): BracketKind =
   if renderIds notin g.flags:
     case n.kind
-    of nkClosedSymChoice, nkOpenSymChoice, nkOpenSym:
+    of nkClosedSymChoice, nkOpenSymChoice:
       if n.len > 0: result = bracketKind(g, n[0])
       else: result = bkNone
     of nkSym:
@@ -1357,10 +1347,6 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
       if not n[0].isExported() and renderNonExportedFields notin g.flags:
         # Skip if this is a property in a type and its not exported
         # (While also not allowing rendering of non exported fields)
-        if shouldRenderComment(g, n):
-          # `shouldRenderComment` indicts that we have comments to render
-          # but it's a non-exported field, so we just pop without rendering any comment
-          discard popCom(g)
         return
       # render postfix for object fields:
       exclFlags = g.flags * {renderNoPostfix}
@@ -1429,7 +1415,10 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
   of nkPrefix:
     gsub(g, n, 0)
     if n.len > 1:
-      let opr = getPIdent(n[0])
+      let opr = if n[0].kind == nkIdent: n[0].ident
+                elif n[0].kind == nkSym: n[0].sym.name
+                elif n[0].kind in {nkOpenSymChoice, nkClosedSymChoice}: n[0][0].sym.name
+                else: nil
       let nNext = skipHiddenNodes(n[1])
       if nNext.kind == nkPrefix or (opr != nil and renderer.isKeyword(opr)):
         put(g, tkSpaces, Space)
@@ -1480,30 +1469,15 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
     putWithSpace(g, tkColon, ":")
     if n.len > 0: gsub(g, n[0], 1)
     gsons(g, n, emptyContext, 1)
-  of nkElifExpr, nkElifBranch:
-    if isEmptyType(n[1].typ):
-      optNL(g)
-      putWithSpace(g, tkElif, "elif")
-      gsub(g, n, 0)
-      putWithSpace(g, tkColon, ":")
-      gcoms(g)
-      gstmts(g, n[1], c)
-    else:
-      putWithSpace(g, tkElif, " elif")
-      gcond(g, n[0])
-      putWithSpace(g, tkColon, ":")
-      gsub(g, n, 1)
-  of nkElseExpr, nkElse:
-    if isEmptyType(n[0].typ):
-      optNL(g)
-      put(g, tkElse, "else")
-      putWithSpace(g, tkColon, ":")
-      gcoms(g)
-      gstmts(g, n[0], c)
-    else:
-      put(g, tkElse, " else")
-      putWithSpace(g, tkColon, ":")
-      gsub(g, n, 0)
+  of nkElifExpr:
+    putWithSpace(g, tkElif, " elif")
+    gcond(g, n[0])
+    putWithSpace(g, tkColon, ":")
+    gsub(g, n, 1)
+  of nkElseExpr:
+    put(g, tkElse, " else")
+    putWithSpace(g, tkColon, ":")
+    gsub(g, n, 0)
   of nkTypeOfExpr:
     put(g, tkType, "typeof")
     put(g, tkParLe, "(")
@@ -1765,6 +1739,19 @@ proc gsub(g: var TSrcGen, n: PNode, c: TContext, fromStmtList = false) =
   of nkMixinStmt:
     putWithSpace(g, tkMixin, "mixin")
     gcomma(g, n, c)
+  of nkElifBranch:
+    optNL(g)
+    putWithSpace(g, tkElif, "elif")
+    gsub(g, n, 0)
+    putWithSpace(g, tkColon, ":")
+    gcoms(g)
+    gstmts(g, n[1], c)
+  of nkElse:
+    optNL(g)
+    put(g, tkElse, "else")
+    putWithSpace(g, tkColon, ":")
+    gcoms(g)
+    gstmts(g, n[0], c)
   of nkFinally, nkDefer:
     optNL(g)
     if n.kind == nkFinally:

compiler/reorder.nim

@@ -93,7 +93,7 @@ proc computeDeps(cache: IdentCache; n: PNode, declares, uses: var IntSet; topLev
   of nkIdent: uses.incl n.ident.id
   of nkSym: uses.incl n.sym.name.id
   of nkAccQuoted: uses.incl accQuoted(cache, n).id
-  of nkOpenSymChoice, nkClosedSymChoice, nkOpenSym:
+  of nkOpenSymChoice, nkClosedSymChoice:
     uses.incl n[0].sym.name.id
   of nkStmtList, nkStmtListExpr, nkWhenStmt, nkElifBranch, nkElse, nkStaticStmt:
     for i in 0..<n.len: computeDeps(cache, n[i], declares, uses, topLevel)

compiler/scriptconfig.nim

@@ -215,7 +215,7 @@ proc runNimScript*(cache: IdentCache; scriptName: AbsoluteFile;
   conf.selectedGC = gcUnselected
 
   var m = graph.makeModule(scriptName)
-  incl(m, sfMainModule)
+  incl(m.flags, sfMainModule)
   var vm = setupVM(m, cache, scriptName.string, graph, idgen)
   graph.vm = vm
 

compiler/sem.nim

@@ -102,7 +102,7 @@ proc fitNode(c: PContext, formal: PType, arg: PNode; info: TLineInfo): PNode =
                renderTree(arg, {renderNoComments}))
     # error correction:
     result = copyTree(arg)
-    result.typ = formal
+    result.typ() = formal
   elif arg.kind in nkSymChoices and formal.skipTypes(abstractInst).kind == tyEnum:
     # Pick the right 'sym' from the sym choice by looking at 'formal' type:
     result = nil
@@ -116,7 +116,7 @@ proc fitNode(c: PContext, formal: PType, arg: PNode; info: TLineInfo): PNode =
       typeMismatch(c.config, info, formal, arg.typ, arg)
       # error correction:
       result = copyTree(arg)
-      result.typ = formal
+      result.typ() = formal
     else:
       result = fitNodePostMatch(c, formal, result)
 
@@ -126,7 +126,7 @@ proc fitNodeConsiderViewType(c: PContext, formal: PType, arg: PNode; info: TLine
     #classifyViewType(formal) != noView:
     result = newNodeIT(nkHiddenAddr, a.info, formal)
     result.add a
-    formal.incl tfVarIsPtr
+    formal.flags.incl tfVarIsPtr
   else:
    result = a
 
@@ -260,7 +260,7 @@ proc newSymG*(kind: TSymKind, n: PNode, c: PContext): PSym =
   else:
     result = newSym(kind, considerQuotedIdent(c, n), c.idgen, getCurrOwner(c), n.info)
     if find(result.name.s, '`') >= 0:
-      result.flagsImpl.incl sfWasGenSym
+      result.flags.incl sfWasGenSym
   #if kind in {skForVar, skLet, skVar} and result.owner.kind == skModule:
   #  incl(result.flags, sfGlobal)
   when defined(nimsuggest):
@@ -321,7 +321,7 @@ proc hasCycle(n: PNode): bool =
       break
   excl n.flags, nfNone
 
-proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: var bool): PNode =
+proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode): PNode =
   # recompute the types as 'eval' isn't guaranteed to construct types nor
   # that the types are sound:
   when true:
@@ -333,7 +333,7 @@ proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: v
       if hasCycle(result):
         result = localErrorNode(c, eOrig, "the resulting AST is cyclic and cannot be processed further")
       else:
-        semmacrosanity.annotateType(result, expectedType, c.config, producedClosure)
+        semmacrosanity.annotateType(result, expectedType, c.config)
   else:
     result = semExprWithType(c, evaluated)
     #result = fitNode(c, e.typ, result) inlined with special case:
@@ -346,19 +346,6 @@ proc fixupTypeAfterEval(c: PContext, evaluated, eOrig: PNode; producedClosure: v
          isArrayConstr(arg):
         arg.typ = eOrig.typ
 
-proc resetEvalPosition(n: PNode) =
-  # resets the eval position of variables because `tryConstExpr` may be
-  # called multiple times on the same node
-  case n.kind
-  of {nkNone..nkNilLit}-{nkSym}:
-    discard
-  of nkSym:
-    if n.sym.kind in {skVar, skLet} and sfGlobal notin n.sym.flags:
-      n.sym.position = 0
-  else:
-    for i in 0..<n.safeLen:
-      resetEvalPosition(n[i])
-
 proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
   var e = semExprWithType(c, n, expectedType = expectedType)
   if e == nil: return
@@ -383,10 +370,7 @@ proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     if result == nil or result.kind == nkEmpty:
       result = nil
     else:
-      var producedClosure = false
-      result = fixupTypeAfterEval(c, result, e, producedClosure)
-      if producedClosure:
-        result = nil
+      result = fixupTypeAfterEval(c, result, e)
 
   except ERecoverableError:
     result = nil
@@ -395,8 +379,6 @@ proc tryConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
     # Restore the error hook
     c.graph.config.structuredErrorHook = tempHook
 
-  resetEvalPosition(n)
-
   c.config.errorCounter = oldErrorCount
   c.config.errorMax = oldErrorMax
   c.config.m.errorOutputs = oldErrorOutputs
@@ -425,10 +407,7 @@ proc semConstExpr(c: PContext, n: PNode; expectedType: PType = nil): PNode =
       # error correction:
       result = e
     else:
-      var producedClosure = false
-      result = fixupTypeAfterEval(c, result, e, producedClosure)
-      if producedClosure:
-        result = nil
+      result = fixupTypeAfterEval(c, result, e)
 
 proc semExprFlagDispatched(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType = nil): PNode =
   if efNeedStatic in flags:
@@ -491,7 +470,7 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
                    renderTree(result, {renderNoComments}))
         result = newSymNode(errorSym(c, result))
       else:
-        result.typ = makeTypeDesc(c, typ)
+        result.typ() = makeTypeDesc(c, typ)
       #result = symNodeFromType(c, typ, n.info)
     else:
       if s.ast[genericParamsPos] != nil and retType.isMetaType:
@@ -521,21 +500,6 @@ proc semAfterMacroCall(c: PContext, call, macroResult: PNode,
   dec(c.config.evalTemplateCounter)
   discard c.friendModules.pop()
 
-proc getLineInfo(n: PNode): TLineInfo =
-  case n.kind
-  of nkPostfix:
-    if len(n) > 1:
-      result = getLineInfo(n[1])
-    else:
-      result = n.info
-  of nkAccQuoted, nkPragmaExpr:
-    if len(n) > 0:
-      result = getLineInfo(n[0])
-    else:
-      result = n.info
-  else:
-    result = n.info
-
 const
   errMissingGenericParamsForTemplate = "'$1' has unspecified generic parameters"
 
@@ -562,9 +526,7 @@ proc semMacroExpr(c: PContext, n, nOrig: PNode, sym: PSym,
   if efNoSemCheck notin flags:
     result = semAfterMacroCall(c, n, result, sym, flags, expectedType)
   if c.config.macrosToExpand.hasKey(sym.name.s):
-    message(c.config, nOrig.info, hintExpandMacro, renderTree(result, {
-      renderNonExportedFields, renderDocComments, renderNoComments
-    }))
+    message(c.config, nOrig.info, hintExpandMacro, renderTree(result))
   result = wrapInComesFrom(nOrig.info, sym, result)
   popInfoContext(c.config)
 
@@ -650,7 +612,7 @@ proc defaultFieldsForTuple(c: PContext, recNode: PNode, hasDefault: var bool, ch
                       newNodeIT(nkType, recNode.info, asgnType)
                     )
       asgnExpr.flags.incl nfSkipFieldChecking
-      asgnExpr.typ = recNode.typ
+      asgnExpr.typ() = recNode.typ
       result.add newTree(nkExprColonExpr, recNode, asgnExpr)
   else:
     raiseAssert "unreachable"
@@ -672,7 +634,7 @@ proc defaultFieldsForTheUninitialized(c: PContext, recNode: PNode, checkDefault:
       if checkDefault: # don't add defaults when checking whether a case branch has default fields
         return
       defaultValue = newIntNode(nkIntLit#[c.graph]#, 0)
-      defaultValue.typ = discriminator.typ
+      defaultValue.typ() = discriminator.typ
     selectedBranch = recNode.pickCaseBranchIndex defaultValue
     defaultValue.flags.incl nfSkipFieldChecking
     result.add newTree(nkExprColonExpr, discriminator, defaultValue)
@@ -685,7 +647,7 @@ proc defaultFieldsForTheUninitialized(c: PContext, recNode: PNode, checkDefault:
     elif recType.kind in {tyObject, tyArray, tyTuple}:
       let asgnExpr = defaultNodeField(c, recNode, recNode.typ, checkDefault)
       if asgnExpr != nil:
-        asgnExpr.typ = recNode.typ
+        asgnExpr.typ() = recNode.typ
         asgnExpr.flags.incl nfSkipFieldChecking
         result.add newTree(nkExprColonExpr, recNode, asgnExpr)
   else:
@@ -698,7 +660,7 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
     let child = defaultFieldsForTheUninitialized(c, aTypSkip.n, checkDefault)
     if child.len > 0:
       var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp))
-      asgnExpr.typ = aTyp
+      asgnExpr.typ() = aTyp
       asgnExpr.sons.add child
       result = semExpr(c, asgnExpr)
     else:
@@ -709,12 +671,11 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
     if child != nil:
       let node = newNode(nkIntLit)
       node.intVal = toInt64(lengthOrd(c.graph.config, aTypSkip))
-      let typeNode = newNode(nkType)
-      typeNode.typ = makeTypeDesc(c, aTypSkip[1])
-      result = semExpr(c, newTree(nkCall, newTree(nkBracketExpr, newSymNode(getSysSym(c.graph, a.info, "arrayWithDefault"), a.info), typeNode),
+      result = semExpr(c, newTree(nkCall, newSymNode(getSysSym(c.graph, a.info, "arrayWith"), a.info),
+              semExprWithType(c, child),
               node
                 ))
-      result.typ = aTyp
+      result.typ() = aTyp
     else:
       result = nil
   of tyTuple:
@@ -723,7 +684,7 @@ proc defaultNodeField(c: PContext, a: PNode, aTyp: PType, checkDefault: bool): P
       let children = defaultFieldsForTuple(c, aTypSkip.n, hasDefault, checkDefault)
       if hasDefault and children.len > 0:
         result = newNodeI(nkTupleConstr, a.info)
-        result.typ = aTyp
+        result.typ() = aTyp
         result.sons.add children
         result = semExpr(c, result)
       else:
@@ -772,11 +733,9 @@ proc preparePContext*(graph: ModuleGraph; module: PSym; idgen: IdGenerator): PCo
   result.semInferredLambda = semInferredLambda
   result.semGenerateInstance = generateInstance
   result.instantiateOnlyProcType = instantiateOnlyProcType
-  result.fitDefaultNode = fitDefaultNode
   result.semTypeNode = semTypeNode
   result.instTypeBoundOp = sigmatch.instTypeBoundOp
   result.hasUnresolvedArgs = hasUnresolvedArgs
-  result.semAsgnOpr = semAsgnOpr
   result.templInstCounter = new int
 
   pushProcCon(result, module)
@@ -894,9 +853,9 @@ proc semWithPContext*(c: PContext, n: PNode): PNode =
 
 proc reportUnusedModules(c: PContext) =
   if c.config.cmd == cmdM: return
-  for (s, info) in c.unusedImports:
-    if sfUsed notin s.flags:
-      message(c.config, info, warnUnusedImportX, s.name.s)
+  for i in 0..high(c.unusedImports):
+    if sfUsed notin c.unusedImports[i][0].flags:
+      message(c.config, c.unusedImports[i][1], warnUnusedImportX, c.unusedImports[i][0].name.s)
 
 proc closePContext*(graph: ModuleGraph; c: PContext, n: PNode): PNode =
   if c.config.cmd == cmdIdeTools and not c.suggestionsMade:

compiler/semcall.nim

@@ -56,7 +56,7 @@ proc initCandidateSymbols(c: PContext, headSymbol: PNode,
           proc name[T: static proc()]() = T()
           name[proc() = echo"hello"]()
       ]#
-      for paramSym in searchScopesAll(c, symx.name, {skConst}):
+      for paramSym in searchInScopesAllCandidatesFilterBy(c, symx.name, {skConst}):
         let paramTyp = paramSym.typ
         if paramTyp.n.kind == nkSym and paramTyp.n.sym.kind in filter:
           result.add((paramTyp.n.sym, o.lastOverloadScope))
@@ -69,39 +69,6 @@ proc initCandidateSymbols(c: PContext, headSymbol: PNode,
                   result[0].scope, diagnostics)
     best.state = csNoMatch
 
-proc isAttachableRoutineTo(prc: PSym, arg: PType): bool =
-  result = false
-  if arg.owner != prc.owner: return false
-  for i in 1 ..< prc.typ.len:
-    if prc.typ.n[i].kind == nkSym and prc.typ.n[i].sym.ast != nil:
-      # has default value, parameter is not considered in type attachment
-      continue
-    let t = nominalRoot(prc.typ[i])
-    if t != nil and t.itemId == arg.itemId:
-      # parameter `i` is a nominal type in this module
-      # attachable if the nominal root `t` has the same id as `arg`
-      return true
-
-proc addTypeBoundSymbols(graph: ModuleGraph, arg: PType, name: PIdent,
-                         filter: TSymKinds, marker: var IntSet,
-                         syms: var seq[tuple[s: PSym, scope: int]]) =
-  # add type bound ops for `name` based on the argument type `arg`
-  if arg != nil:
-    # argument must be typed first, meaning arguments always
-    # matching `untyped` are ignored
-    let t = nominalRoot(arg)
-    if t != nil and t.owner.kind == skModule:
-      # search module for routines attachable to `t`
-      let module = t.owner
-      var iter = default(ModuleIter)
-      var s = initModuleIter(iter, graph, module, name)
-      while s != nil:
-        if s.kind in filter and s.isAttachableRoutineTo(t) and
-            not containsOrIncl(marker, s.id):
-          # least priority scope, less than explicit imports:
-          syms.add((s, -2))
-        s = nextModuleIter(iter, graph)
-
 proc pickBestCandidate(c: PContext, headSymbol: PNode,
                        n, orig: PNode,
                        initialBinding: PNode,
@@ -121,29 +88,17 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
                                   best, alt, o, diagnosticsFlag)
   if len(syms) == 0:
     return
-  let allowTypeBoundOps = typeBoundOps in c.features and
-    # qualified or bound symbols cannot refer to type bound ops
-    headSymbol.kind in {nkIdent, nkAccQuoted, nkOpenSymChoice, nkOpenSym}
-  var symMarker = initIntSet()
-  for s in syms:
-    symMarker.incl(s.s.id)
   # current overload being considered
   var sym = syms[0].s
-  let name = sym.name
   var scope = syms[0].scope
 
-  if allowTypeBoundOps:
-    for a in 1 ..< n.len:
-      # for every already typed argument, add type bound ops
-      let arg = n[a]
-      addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
-
   # starts at 1 because 0 is already done with setup, only needs checking
   var nextSymIndex = 1
   var z: TCandidate # current candidate
   while true:
     determineType(c, sym)
     z = initCandidate(c, sym, initialBinding, scope, diagnosticsFlag)
+
     # this is kinda backwards as without a check here the described
     # problems in recalc would not happen, but instead it 100%
     # does check forever in some cases
@@ -151,14 +106,6 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
       # may introduce new symbols with caveats described in recalc branch
       matches(c, n, orig, z)
 
-      if allowTypeBoundOps:
-        # this match may have given some arguments new types,
-        # in which case add their type bound ops as well
-        # type bound ops of arguments always matching `untyped` are not considered
-        for x in z.newlyTypedOperands:
-          let arg = n[x]
-          addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
-
       if z.state == csMatch:
         # little hack so that iterators are preferred over everything else:
         if sym.kind == skIterator:
@@ -183,20 +130,13 @@ proc pickBestCandidate(c: PContext, headSymbol: PNode,
       # 1) new symbols are discovered but the loop ends before we recalc
       # 2) new symbols are discovered and resemmed forever
       # not 100% sure if these are possible though as they would rely
-      # on somehow introducing a new overload during overload resolution
+      #  on somehow introducing a new overload during overload resolution
 
       # Symbol table has been modified. Restart and pre-calculate all syms
       # before any further candidate init and compare. SLOW, but rare case.
       syms = initCandidateSymbols(c, headSymbol, initialBinding, filter,
                                   best, alt, o, diagnosticsFlag)
-      symMarker = initIntSet()
-      for s in syms:
-        symMarker.incl(s.s.id)
-      if allowTypeBoundOps:
-        for a in 1 ..< n.len:
-          # for every already typed argument, add type bound ops
-          let arg = n[a]
-          addTypeBoundSymbols(c.graph, arg.typ, name, filter, symMarker, syms)
+
       # reset counter because syms may be in a new order
       symCount = c.currentScope.symbols.counter
       nextSymIndex = 0
@@ -244,6 +184,14 @@ proc effectProblem(f, a: PType; result: var string; c: PContext) =
         if not c.graph.compatibleProps(c.graph, f, a):
           result.add "\n  The `.requires` or `.ensures` properties are incompatible."
 
+proc renderNotLValue(n: PNode): string =
+  result = $n
+  let n = if n.kind == nkHiddenDeref: n[0] else: n
+  if n.kind == nkHiddenCallConv and n.len > 1:
+    result = $n[0] & "(" & result & ")"
+  elif n.kind in {nkHiddenStdConv, nkHiddenSubConv} and n.len == 2:
+    result = typeToString(n.typ.skipTypes(abstractVar)) & "(" & result & ")"
+
 proc presentFailedCandidates(c: PContext, n: PNode, errors: CandidateErrors):
                             (TPreferedDesc, string) =
   var prefer = preferName
@@ -581,7 +529,7 @@ proc resolveOverloads(c: PContext, n, orig: PNode,
   let overloadsState = result.state
   if overloadsState != csMatch:
     if nfDotField in n.flags:
-      internalAssert c.config, f.kind in nkIdentKinds and n.len >= 2
+      internalAssert c.config, f.kind == nkIdent and n.len >= 2
 
       # leave the op head symbol empty,
       # we are going to try multiple variants
@@ -686,16 +634,9 @@ proc instGenericConvertersArg*(c: PContext, a: PNode, x: TCandidate) =
   if a.kind == nkHiddenCallConv and a[0].kind == nkSym:
     let s = a[0].sym
     if s.isGenericRoutineStrict:
-      var src = s.typ.firstParamType
-      var convMatch = newCandidate(c, src)
-      var arg = a[1]
-      if arg.kind in {nkHiddenAddr, nkHiddenSubConv}: arg = arg[^1]
-      let srca = typeRel(convMatch, src, arg.typ)
-      if srca notin {isEqual, isGeneric, isSubtype}:
-        internalError(c.config, a.info, "generic converter failed rematch")
-      let finalCallee = generateInstance(c, s, convMatch.bindings, a.info)
+      let finalCallee = generateInstance(c, s, x.bindings, a.info)
       a[0].sym = finalCallee
-      a[0].typ = finalCallee.typ
+      a[0].typ() = finalCallee.typ
       #a.typ = finalCallee.typ.returnType
 
 proc instGenericConvertersSons*(c: PContext, n: PNode, x: TCandidate) =
@@ -730,13 +671,13 @@ proc inferWithMetatype(c: PContext, formal: PType,
     # This almost exactly replicates the steps taken by the compiler during
     # param matching. It performs an embarrassing amount of back-and-forth
     # type jugling, but it's the price to pay for consistency and correctness
-    result.typ = generateTypeInstance(c, m.bindings, arg.info,
+    result.typ() = generateTypeInstance(c, m.bindings, arg.info,
                                       formal.skipTypes({tyCompositeTypeClass}))
   else:
     typeMismatch(c.config, arg.info, formal, arg.typ, arg)
     # error correction:
     result = copyTree(arg)
-    result.typ = formal
+    result.typ() = formal
 
 proc updateDefaultParams(c: PContext, call: PNode) =
   # In generic procs, the default parameter may be unique for each
@@ -759,7 +700,7 @@ proc updateDefaultParams(c: PContext, call: PNode) =
         pushInfoContext(c.config, call.info, call[0].sym.detailedInfo)
         typeMismatch(c.config, def.info, formal.typ, def.typ, formal.ast)
         popInfoContext(c.config)
-        def.typ = errorType(c)
+        def.typ() = errorType(c)
       call[i] = def
 
 proc getCallLineInfo(n: PNode): TLineInfo =
@@ -836,18 +777,15 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
   assert x.state == csMatch
   var finalCallee = x.calleeSym
   let info = getCallLineInfo(n)
-  markUsed(c, info, finalCallee, isGenericInstance = false)
-  onUse(info, finalCallee, isGenericInstance = false)
+  markUsed(c, info, finalCallee)
+  onUse(info, finalCallee)
   assert finalCallee.ast != nil
-  if x.matchedErrorType:
-    markUsed(c, info, finalCallee, isGenericInstance = true)
-    onUse(info, finalCallee, isGenericInstance = true)
   if x.matchedErrorType:
     result = x.call
     result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
     if containsGenericType(result.typ):
-      result.typ = newTypeS(tyError, c)
-      incl result.typ, tfCheckedForDestructor
+      result.typ() = newTypeS(tyError, c)
+      incl result.typ.flags, tfCheckedForDestructor
     return
   let gp = finalCallee.ast[genericParamsPos]
   if gp.isGenericParams:
@@ -873,19 +811,17 @@ proc semResolvedCall(c: PContext, x: var TCandidate,
           # this node will be used in template substitution,
           # pretend this is an untyped node and let regular sem handle the type
           # to prevent problems where a generic parameter is treated as a value
-          tn.typ = nil
+          tn.typ() = nil
           x.call.add tn
         else:
           internalAssert c.config, false
-  markUsed(c, info, finalCallee, isGenericInstance = true)
-  onUse(info, finalCallee, isGenericInstance = true)
 
   result = x.call
   instGenericConvertersSons(c, result, x)
   markConvertersUsed(c, result)
   result[0] = newSymNode(finalCallee, getCallLineInfo(result[0]))
   if finalCallee.magic notin {mArrGet, mArrPut}:
-    result.typ = finalCallee.typ.returnType
+    result.typ() = finalCallee.typ.returnType
   updateDefaultParams(c, result)
 
 proc canDeref(n: PNode): bool {.inline.} =
@@ -894,7 +830,7 @@ proc canDeref(n: PNode): bool {.inline.} =
 
 proc tryDeref(n: PNode): PNode =
   result = newNodeI(nkHiddenDeref, n.info)
-  result.typ = n.typ.skipTypes(abstractInst)[0]
+  result.typ() = n.typ.skipTypes(abstractInst)[0]
   result.add n
 
 proc semOverloadedCall(c: PContext, n, nOrig: PNode,
@@ -913,16 +849,16 @@ proc semOverloadedCall(c: PContext, n, nOrig: PNode,
   else:
     if c.inGenericContext > 0 and c.matchedConcept == nil:
       result = semGenericStmt(c, n)
-      result.typ = makeTypeFromExpr(c, result.copyTree)
-    elif efNoUndeclared in flags:
-      result = nil
+      result.typ() = makeTypeFromExpr(c, result.copyTree)
     elif efExplain notin flags:
       # repeat the overload resolution,
       # this time enabling all the diagnostic output (this should fail again)
       result = semOverloadedCall(c, n, nOrig, filter, flags + {efExplain})
-    else:
+    elif efNoUndeclared notin flags:
       result = nil
       notFoundError(c, n, errors)
+    else:
+      result = nil
 
 proc explicitGenericInstError(c: PContext; n: PNode): PNode =
   localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
@@ -945,12 +881,10 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym, errors: var CandidateErr
         diagnostics: m.diagnostics))
     return nil
   var newInst = generateInstance(c, s, m.bindings, n.info)
-  newInst.typ.excl tfUnresolved
+  newInst.typ.flags.excl tfUnresolved
   let info = getCallLineInfo(n)
-  markUsed(c, info, s, isGenericInstance = false)
-  onUse(info, s, isGenericInstance = false)
-  markUsed(c, info, newInst, isGenericInstance = true)
-  onUse(info, newInst, isGenericInstance = true)
+  markUsed(c, info, s)
+  onUse(info, s)
   result = newSymNode(newInst, info)
 
 proc setGenericParams(c: PContext, n, expectedParams: PNode) =
@@ -964,9 +898,9 @@ proc setGenericParams(c: PContext, n, expectedParams: PNode) =
           nil
       e = semExprWithType(c, n[i], expectedType = constraint)
     if e.typ == nil:
-      n[i].typ = errorType(c)
+      n[i].typ() = errorType(c)
     else:
-      n[i].typ = e.typ.skipTypes({tyTypeDesc})
+      n[i].typ() = e.typ.skipTypes({tyTypeDesc})
 
 proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool): PNode =
   assert n.kind == nkBracketExpr
@@ -978,14 +912,8 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool)
     # common case; check the only candidate has the right
     # number of generic type parameters:
     result = explicitGenericSym(c, n, s, errors, doError)
-    if result == nil:
-      if c.inGenericContext > 0:
-        # same as in semOverloadedCall, make expression untyped,
-        # may have failed match due to unresolved types
-        result = semGenericStmt(c, n)
-        result.typ = makeTypeFromExpr(c, result.copyTree)
-      elif doError:
-        notFoundError(c, n, errors)
+    if doError and result == nil:
+      notFoundError(c, n, errors)
   elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
     # choose the generic proc with the proper number of type parameters.
     result = newNodeI(a.kind, getCallLineInfo(n))
@@ -995,14 +923,6 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym, doError: bool)
                             skFunc, skIterator}:
         let x = explicitGenericSym(c, n, candidate, errors, doError)
         if x != nil: result.add(x)
-        elif c.inGenericContext > 0:
-          # same as in semOverloadedCall, make expression untyped,
-          # may have failed match due to unresolved types
-          # any failing match stops building the symchoice for correctness,
-          # can also make it untyped from the start
-          result = semGenericStmt(c, n)
-          result.typ = makeTypeFromExpr(c, result.copyTree)
-          return
     # get rid of nkClosedSymChoice if not ambiguous:
     if result.len == 0:
       result = nil

compiler/semdata.nim

@@ -9,15 +9,14 @@
 
 ## This module contains the data structures for the semantic checking phase.
 
-import std/[tables, intsets, sets, strutils]
+import std/[tables, intsets, sets]
 
 when defined(nimPreviewSlimSystem):
   import std/assertions
 
 import
   options, ast, msgs, idents, renderer,
-  magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable,
-  types, lowerings, trees, parampatterns, astalgo
+  magicsys, vmdef, modulegraphs, lineinfos, pathutils, layeredtable
 
 import ic / ic
 
@@ -42,7 +41,7 @@ type
     breakInLoop*: bool        # whether we are in a loop without block
     next*: PProcCon           # used for stacking procedure contexts
     mappingExists*: bool
-    mapping*: SymMapping
+    mapping*: Table[ItemId, PSym]
     caseContext*: seq[tuple[n: PNode, idx: int]]
     localBindStmts*: seq[PNode]
 
@@ -143,7 +142,6 @@ type
     instantiateOnlyProcType*: proc (c: PContext, pt: LayeredIdTable,
                                     prc: PSym, info: TLineInfo): PType
       # used by sigmatch for explicit generic instantiations
-    fitDefaultNode*: proc (c: PContext, n: var PNode, expectedType: PType)
     includedFiles*: IntSet    # used to detect recursive include files
     pureEnumFields*: TStrTable   # pure enum fields that can be used unambiguously
     userPragmas*: TStrTable
@@ -153,6 +151,7 @@ type
     generics*: seq[TInstantiationPair] # pending list of instantiated generics to compile
     topStmts*: int # counts the number of encountered top level statements
     lastGenericIdx*: int      # used for the generics stack
+    hloLoopDetector*: int     # used to prevent endless loops in the HLO
     inParallelStmt*: int
     instTypeBoundOp*: proc (c: PContext; dc: PSym; t: PType; info: TLineInfo;
                             op: TTypeAttachedOp; col: int): PSym {.nimcall.}
@@ -171,13 +170,8 @@ type
     sideEffects*: Table[int, seq[(TLineInfo, PSym)]] # symbol.id index
     inUncheckedAssignSection*: int
     importModuleLookup*: Table[int, seq[int]] # (module.ident.id, [module.id])
-    forwardTypeUpdates*: seq[(PType, PNode)]
-      # types that need to be updated in a type section
-      # due to containing forward types, and their corresponding nodes
+    skipTypes*: seq[PNode] # used to skip types between passes in type section. So far only used for inheritance, sets and generic bodies.
     inTypeofContext*: int
-
-    semAsgnOpr*: proc (c: PContext; n: PNode; k: TNodeKind): PNode {.nimcall.}
-
   TBorrowState* = enum
     bsNone, bsReturnNotMatch, bsNoDistinct, bsGeneric, bsNotSupported, bsMatch
 
@@ -201,29 +195,29 @@ proc getIntLitType*(c: PContext; literal: PNode): PType =
 proc setIntLitType*(c: PContext; result: PNode) =
   let i = result.intVal
   case c.config.target.intSize
-  of 8: result.typ = getIntLitType(c, result)
+  of 8: result.typ() = getIntLitType(c, result)
   of 4:
     if i >= low(int32) and i <= high(int32):
-      result.typ = getIntLitType(c, result)
+      result.typ() = getIntLitType(c, result)
     else:
-      result.typ = getSysType(c.graph, result.info, tyInt64)
+      result.typ() = getSysType(c.graph, result.info, tyInt64)
   of 2:
     if i >= low(int16) and i <= high(int16):
-      result.typ = getIntLitType(c, result)
+      result.typ() = getIntLitType(c, result)
     elif i >= low(int32) and i <= high(int32):
-      result.typ = getSysType(c.graph, result.info, tyInt32)
+      result.typ() = getSysType(c.graph, result.info, tyInt32)
     else:
-      result.typ = getSysType(c.graph, result.info, tyInt64)
+      result.typ() = getSysType(c.graph, result.info, tyInt64)
   of 1:
     # 8 bit CPUs are insane ...
     if i >= low(int8) and i <= high(int8):
-      result.typ = getIntLitType(c, result)
+      result.typ() = getIntLitType(c, result)
     elif i >= low(int16) and i <= high(int16):
-      result.typ = getSysType(c.graph, result.info, tyInt16)
+      result.typ() = getSysType(c.graph, result.info, tyInt16)
     elif i >= low(int32) and i <= high(int32):
-      result.typ = getSysType(c.graph, result.info, tyInt32)
+      result.typ() = getSysType(c.graph, result.info, tyInt32)
     else:
-      result.typ = getSysType(c.graph, result.info, tyInt64)
+      result.typ() = getSysType(c.graph, result.info, tyInt64)
   else:
     internalError(c.config, result.info, "invalid int size")
 
@@ -259,7 +253,7 @@ proc popProcCon*(c: PContext) {.inline.} = c.p = c.p.next
 
 proc put*(p: PProcCon; key, val: PSym) =
   if not p.mappingExists:
-    p.mapping = initSymMapping()
+    p.mapping = initTable[ItemId, PSym]()
     p.mappingExists = true
   #echo "put into table ", key.info
   p.mapping[key.itemId] = val
@@ -291,24 +285,22 @@ proc considerGenSyms*(c: PContext; n: PNode) =
       considerGenSyms(c, n[i])
 
 proc newOptionEntry*(conf: ConfigRef): POptionEntry =
-  result = POptionEntry(
-    options: conf.options,
-    defaultCC: ccNimCall,
-    dynlib: nil,
-    notes: conf.notes,
-    warningAsErrors: conf.warningAsErrors
-  )
+  new(result)
+  result.options = conf.options
+  result.defaultCC = ccNimCall
+  result.dynlib = nil
+  result.notes = conf.notes
+  result.warningAsErrors = conf.warningAsErrors
 
 proc pushOptionEntry*(c: PContext): POptionEntry =
-  let prev = c.optionStack[^1]
-  result = POptionEntry(
-    options: c.config.options,
-    defaultCC: prev.defaultCC,
-    dynlib: prev.dynlib,
-    notes: c.config.notes,
-    warningAsErrors: c.config.warningAsErrors,
-    features: c.features
-  )
+  new(result)
+  var prev = c.optionStack[^1]
+  result.options = c.config.options
+  result.defaultCC = prev.defaultCC
+  result.dynlib = prev.dynlib
+  result.notes = c.config.notes
+  result.warningAsErrors = c.config.warningAsErrors
+  result.features = c.features
   c.optionStack.add(result)
 
 proc popOptionEntry*(c: PContext) =
@@ -319,23 +311,22 @@ proc popOptionEntry*(c: PContext) =
   c.optionStack.setLen(c.optionStack.len - 1)
 
 proc newContext*(graph: ModuleGraph; module: PSym): PContext =
-  result = PContext(
-    optionStack: @[newOptionEntry(graph.config)],
-    libs: @[],
-    module: module,
-    friendModules: @[module],
-    converters: @[],
-    patterns: @[],
-    includedFiles: initIntSet(),
-    pureEnumFields: initStrTable(),
-    userPragmas: initStrTable(),
-    generics: @[],
-    unknownIdents: initIntSet(),
-    cache: graph.cache,
-    graph: graph,
-    signatures: initStrTable(),
-    features: graph.config.features
-  )
+  new(result)
+  result.optionStack = @[newOptionEntry(graph.config)]
+  result.libs = @[]
+  result.module = module
+  result.friendModules = @[module]
+  result.converters = @[]
+  result.patterns = @[]
+  result.includedFiles = initIntSet()
+  result.pureEnumFields = initStrTable()
+  result.userPragmas = initStrTable()
+  result.generics = @[]
+  result.unknownIdents = initIntSet()
+  result.cache = graph.cache
+  result.graph = graph
+  result.signatures = initStrTable()
+  result.features = graph.config.features
   if graph.config.symbolFiles != disabledSf:
     let id = module.position
     if graph.config.cmd != cmdM:
@@ -358,9 +349,6 @@ proc addImportFileDep*(c: PContext; f: FileIndex) =
 proc addPragmaComputation*(c: PContext; n: PNode) =
   if c.config.symbolFiles != disabledSf:
     addPragmaComputation(c.encoder, c.packedRepr, n)
-  # Also store for NIF-based IC (cmdM mode or optCompress)
-  if optCompress in c.config.globalOptions or c.config.cmd == cmdM:
-    addNifReplayAction(c.graph, c.module.position.int32, n)
 
 proc inclSym(sq: var seq[PSym], s: PSym): bool =
   for i in 0..<sq.len:
@@ -402,7 +390,8 @@ proc reexportSym*(c: PContext; s: PSym) =
     addReexport(c.encoder, c.packedRepr, s)
 
 proc newLib*(kind: TLibKind): PLib =
-  result = PLib(kind: kind)   #result.syms = initObjectSet()
+  new(result)
+  result.kind = kind          #result.syms = initObjectSet()
 
 proc addToLib*(lib: PLib, sym: PSym) =
   #if sym.annex != nil and not isGenericRoutine(sym):
@@ -436,7 +425,7 @@ proc makeVarType*(c: PContext, baseType: PType; kind = tyVar): PType =
 
 proc makeTypeSymNode*(c: PContext, typ: PType, info: TLineInfo): PNode =
   let typedesc = newTypeS(tyTypeDesc, c)
-  incl typedesc.flagsImpl, tfCheckedForDestructor
+  incl typedesc.flags, tfCheckedForDestructor
   internalAssert(c.config, typ != nil)
   typedesc.addSonSkipIntLit(typ, c.idgen)
   let sym = newSym(skType, c.cache.idAnon, c.idgen, getCurrOwner(c), info,
@@ -460,7 +449,7 @@ when false:
 proc makeStaticExpr*(c: PContext, n: PNode): PNode =
   result = newNodeI(nkStaticExpr, n.info)
   result.sons = @[n]
-  result.typ = if n.typ != nil and n.typ.kind == tyStatic: n.typ
+  result.typ() = if n.typ != nil and n.typ.kind == tyStatic: n.typ
                else: newTypeS(tyStatic, c, n.typ)
 
 proc makeAndType*(c: PContext, t1, t2: PType): PType =
@@ -469,8 +458,8 @@ proc makeAndType*(c: PContext, t1, t2: PType): PType =
   result.rawAddSon t2
   propagateToOwner(result, t1)
   propagateToOwner(result, t2)
-  result.flagsImpl.incl((t1.flags + t2.flags) * {tfHasStatic})
-  result.flagsImpl.incl tfHasMeta
+  result.flags.incl((t1.flags + t2.flags) * {tfHasStatic})
+  result.flags.incl tfHasMeta
 
 proc makeOrType*(c: PContext, t1, t2: PType): PType =
   if t1.kind != tyOr and t2.kind != tyOr:
@@ -488,14 +477,14 @@ proc makeOrType*(c: PContext, t1, t2: PType): PType =
     addOr(t2)
   propagateToOwner(result, t1)
   propagateToOwner(result, t2)
-  result.incl((t1.flags + t2.flags) * {tfHasStatic})
-  result.incl tfHasMeta
+  result.flags.incl((t1.flags + t2.flags) * {tfHasStatic})
+  result.flags.incl tfHasMeta
 
 proc makeNotType*(c: PContext, t1: PType): PType =
   result = newTypeS(tyNot, c, son = t1)
   propagateToOwner(result, t1)
-  result.flagsImpl.incl(t1.flags * {tfHasStatic})
-  result.flagsImpl.incl tfHasMeta
+  result.flags.incl(t1.flags * {tfHasStatic})
+  result.flags.incl tfHasMeta
 
 proc nMinusOne(c: PContext; n: PNode): PNode =
   result = newTreeI(nkCall, n.info, newSymNode(getSysMagic(c.graph, n.info, "pred", mPred)), n)
@@ -505,7 +494,7 @@ proc makeRangeWithStaticExpr*(c: PContext, n: PNode): PType =
   let intType = getSysType(c.graph, n.info, tyInt)
   result = newTypeS(tyRange, c, son = intType)
   if n.typ != nil and n.typ.n == nil:
-    result.incl tfUnresolved
+    result.flags.incl tfUnresolved
   result.n = newTreeI(nkRange, n.info, newIntTypeNode(0, intType),
     makeStaticExpr(c, nMinusOne(c, n)))
 
@@ -515,11 +504,11 @@ template rangeHasUnresolvedStatic*(t: PType): bool =
 proc errorType*(c: PContext): PType =
   ## creates a type representing an error state
   result = newTypeS(tyError, c)
-  result.flagsImpl.incl tfCheckedForDestructor
+  result.flags.incl tfCheckedForDestructor
 
 proc errorNode*(c: PContext, n: PNode): PNode =
   result = newNodeI(nkEmpty, n.info)
-  result.typ = errorType(c)
+  result.typ() = errorType(c)
 
 # These mimic localError
 template localErrorNode*(c: PContext, n: PNode, info: TLineInfo, msg: TMsgKind, arg: string): PNode =
@@ -565,21 +554,21 @@ proc makeTypeDesc*(c: PContext, typ: PType): PType =
     result = typ
   else:
     result = newTypeS(tyTypeDesc, c, skipIntLit(typ, c.idgen))
-    incl result, tfCheckedForDestructor
+    incl result.flags, tfCheckedForDestructor
 
 proc symFromType*(c: PContext; t: PType, info: TLineInfo): PSym =
   if t.sym != nil: return t.sym
   result = newSym(skType, getIdent(c.cache, "AnonType"), c.idgen, t.owner, info)
-  result.flagsImpl.incl sfAnon
+  result.flags.incl sfAnon
   result.typ = t
 
 proc symNodeFromType*(c: PContext, t: PType, info: TLineInfo): PNode =
   result = newSymNode(symFromType(c, t, info), info)
-  result.typ = makeTypeDesc(c, t)
+  result.typ() = makeTypeDesc(c, t)
 
 proc markIndirect*(c: PContext, s: PSym) {.inline.} =
   if s.kind in {skProc, skFunc, skConverter, skMethod, skIterator}:
-    incl(s.flagsImpl, sfAddrTaken)
+    incl(s.flags, sfAddrTaken)
     # XXX add to 'c' for global analysis
 
 proc illFormedAst*(n: PNode; conf: ConfigRef) =
@@ -645,166 +634,3 @@ proc rememberExpansion*(c: PContext; info: TLineInfo; expandedSym: PSym) =
   ## delegated to the "rod" file mechanism.
   if c.config.symbolFiles != disabledSf:
     storeExpansion(c.encoder, c.packedRepr, info, expandedSym)
-
-const
-  errVarForOutParamNeededX = "for a 'var' type a variable needs to be passed; but '$1' is immutable"
-  errXStackEscape = "address of '$1' may not escape its stack frame"
-
-proc renderNotLValue*(n: PNode): string =
-  result = $n
-  let n = if n.kind == nkHiddenDeref: n[0] else: n
-  if n.kind == nkHiddenCallConv and n.len > 1:
-    result = $n[0] & "(" & result & ")"
-  elif n.kind in {nkHiddenStdConv, nkHiddenSubConv} and n.len == 2:
-    result = typeToString(n.typ.skipTypes(abstractVar)) & "(" & result & ")"
-
-proc isAssignable(c: PContext, n: PNode): TAssignableResult =
-  result = parampatterns.isAssignable(c.p.owner, n)
-
-proc newHiddenAddrTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
-  if n.kind == nkHiddenDeref and not (c.config.backend == backendCpp or
-                                      sfCompileToCpp in c.module.flags):
-    checkSonsLen(n, 1, c.config)
-    result = n[0]
-  else:
-    result = newNodeIT(nkHiddenAddr, n.info, makeVarType(c, n.typ))
-    result.add n
-    let aa = isAssignable(c, n)
-    let sym = getRoot(n)
-    if aa notin {arLValue, arLocalLValue}:
-      if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
-        discard "allow access within a cast(unsafeAssign) section"
-      elif strictDefs in c.features and aa == arAddressableConst and
-              sym != nil and sym.kind == skLet and isOutParam:
-        discard "allow let varaibles to be passed to out parameters"
-      else:
-        localError(c.config, n.info, errVarForOutParamNeededX % renderNotLValue(n))
-
-proc analyseIfAddressTaken(c: PContext, n: PNode, isOutParam: bool): PNode =
-  result = n
-  case n.kind
-  of nkSym:
-    # n.sym.typ can be nil in 'check' mode ...
-    if n.sym.typ != nil and
-        skipTypes(n.sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      incl(n.sym.flagsImpl, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  of nkDotExpr:
-    checkSonsLen(n, 2, c.config)
-    if n[1].kind != nkSym:
-      internalError(c.config, n.info, "analyseIfAddressTaken")
-      return
-    if skipTypes(n[1].sym.typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      incl(n[1].sym.flagsImpl, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  of nkBracketExpr:
-    checkMinSonsLen(n, 1, c.config)
-    if skipTypes(n[0].typ, abstractInst-{tyTypeDesc}).kind notin {tyVar, tyLent}:
-      if n[0].kind == nkSym: incl(n[0].sym.flagsImpl, sfAddrTaken)
-      result = newHiddenAddrTaken(c, n, isOutParam)
-  else:
-    result = newHiddenAddrTaken(c, n, isOutParam)
-
-proc analyseIfAddressTakenInCall*(c: PContext, n: PNode, isConverter = false) =
-  checkMinSonsLen(n, 1, c.config)
-  if n[0].typ == nil:
-    # n[0] might be erroring node in nimsuggest
-    return
-  const
-    FakeVarParams = {mNew, mNewFinalize, mInc, ast.mDec, mIncl, mExcl,
-      mSetLengthStr, mSetLengthSeq, mSetLengthSeqUninit, mAppendStrCh, mAppendStrStr, mSwap,
-      mAppendSeqElem, mNewSeq, mShallowCopy, mDeepCopy, mMove, mWasMoved}
-
-  template checkIfConverterCalled(c: PContext, n: PNode) =
-    ## Checks if there is a converter call which wouldn't be checked otherwise
-    # Call can sometimes be wrapped in a deref
-    let node = if n.kind == nkHiddenDeref: n[0] else: n
-    if node.kind == nkHiddenCallConv:
-      analyseIfAddressTakenInCall(c, node, true)
-  # get the real type of the callee
-  # it may be a proc var with a generic alias type, so we skip over them
-  var t = n[0].typ.skipTypes({tyGenericInst, tyAlias, tySink})
-  if n[0].kind == nkSym and n[0].sym.magic in FakeVarParams:
-    # BUGFIX: check for L-Value still needs to be done for the arguments!
-    # note sometimes this is eval'ed twice so we check for nkHiddenAddr here:
-    for i in 1..<n.len:
-      if i < t.len and t[i] != nil and
-          skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
-        let it = n[i]
-        let aa = isAssignable(c, it)
-        if aa notin {arLValue, arLocalLValue}:
-          if it.kind != nkHiddenAddr:
-            if aa == arDiscriminant and c.inUncheckedAssignSection > 0:
-              discard "allow access within a cast(unsafeAssign) section"
-            else:
-              localError(c.config, it.info, errVarForOutParamNeededX % $it)
-        # Make sure to still check arguments for converters
-        c.checkIfConverterCalled(n[i])
-    # bug #5113: disallow newSeq(result) where result is a 'var T':
-    if n[0].sym.magic in {mNew, mNewFinalize, mNewSeq}:
-      var arg = n[1] #.skipAddr
-      if arg.kind == nkHiddenDeref: arg = arg[0]
-      if arg.kind == nkSym and arg.sym.kind == skResult and
-          arg.typ.skipTypes(abstractInst).kind in {tyVar, tyLent}:
-        localError(c.config, n.info, errXStackEscape % renderTree(n[1], {renderNoComments}))
-
-    return
-  for i in 1..<n.len:
-    let n = if n.kind == nkHiddenDeref: n[0] else: n
-    c.checkIfConverterCalled(n[i])
-    if i < t.len and
-        skipTypes(t[i], abstractInst-{tyTypeDesc}).kind in {tyVar}:
-      # Converters wrap var parameters in nkHiddenAddr but they haven't been analysed yet.
-      # So we need to make sure we are checking them still when in a converter call
-      if n[i].kind != nkHiddenAddr or isConverter:
-        n[i] = analyseIfAddressTaken(c, n[i].skipAddr(), isOutParam(skipTypes(t[i], abstractInst-{tyTypeDesc})))
-
-
-proc replaceHookMagic*(c: PContext, n: PNode, kind: TTypeAttachedOp): PNode =
-  ## Replaces builtin generic hooks with lifted hooks.
-  case kind
-  of attachedDestructor:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedDestructor)
-    if op != nil:
-      result[0] = newSymNode(op)
-      if op.typ != nil and op.typ.len == 2 and op.typ.firstParamType.kind != tyVar:
-        if n[1].kind == nkSym and n[1].sym.kind == skParam and
-            n[1].typ.kind == tyVar:
-          result[1] = genDeref(n[1])
-        else:
-          result[1] = skipAddr(n[1])
-  of attachedTrace:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedTrace)
-    if op != nil:
-      result[0] = newSymNode(op)
-  of attachedDup:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedDup)
-    if op != nil:
-      result[0] = newSymNode(op)
-      if op.typ.len == 3:
-        let boolLit = newIntLit(c.graph, n.info, 1)
-        boolLit.typ = getSysType(c.graph, n.info, tyBool)
-        result.add boolLit
-  of attachedWasMoved:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, attachedWasMoved)
-    if op != nil:
-      result[0] = newSymNode(op)
-      analyseIfAddressTakenInCall(c, result, false)
-  of attachedSink:
-    result = c.semAsgnOpr(c, n, nkSinkAsgn)
-  of attachedAsgn:
-    result = c.semAsgnOpr(c, n, nkAsgn)
-  of attachedDeepCopy:
-    result = n
-    let t = n[1].typ.skipTypes(abstractVar)
-    let op = getAttachedOp(c.graph, t, kind)
-    if op != nil:
-      result[0] = newSymNode(op)

compiler/semfields.nim

@@ -17,17 +17,9 @@ type
     field: PSym
     replaceByFieldName: bool
     c: PContext
+    leftPartOfDefinition: bool
 
-proc wrapNewScope(c: PContext, n: PNode): PNode {.inline.} =
-  # use `if true` to not interfere with `break`
-  # just opening scope via `openScope(c)` isn't enough,
-  # a scope has to be opened in the codegen as well for reused
-  # template instantiations
-  let trueLit = newIntLit(c.graph, n.info, 1)
-  trueLit.typ = getSysType(c.graph, n.info, tyBool)
-  result = newTreeI(nkIfStmt, n.info, newTreeI(nkElifBranch, n.info, trueLit, n))
-
-proc instFieldLoopBody(c: TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
+proc instFieldLoopBody(c: var TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
   if c.field != nil and isEmptyType(c.field.typ):
     result = newNode(nkEmpty)
     return
@@ -36,9 +28,11 @@ proc instFieldLoopBody(c: TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
   of nkIdent, nkSym:
     result = n
     let ident = considerQuotedIdent(c.c, n)
-    if c.replaceByFieldName and
-        ident.id != ord(wUnderscore):
+    if c.replaceByFieldName:
       if ident.id == considerQuotedIdent(c.c, forLoop[0]).id:
+        if c.leftPartOfDefinition:
+          localError(c.c.config, n.info,
+                  "redefine field variable '$1' in a 'fields' loop" % [ident.s])
         let fieldName = if c.tupleType.isNil: c.field.name.s
                         elif c.tupleType.n.isNil: "Field" & $c.tupleIndex
                         else: c.tupleType.n[c.tupleIndex].sym.name.s
@@ -46,8 +40,10 @@ proc instFieldLoopBody(c: TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
         return
     # other fields:
     for i in ord(c.replaceByFieldName)..<forLoop.len-2:
-      if ident.id == considerQuotedIdent(c.c, forLoop[i]).id and
-            ident.id != ord(wUnderscore):
+      if ident.id == considerQuotedIdent(c.c, forLoop[i]).id:
+        if c.leftPartOfDefinition:
+          localError(c.c.config, n.info,
+                    "redefine field variable '$1' in a 'fields' loop" % [ident.s])
         var call = forLoop[^2]
         var tupl = call[i+1-ord(c.replaceByFieldName)]
         if c.field.isNil:
@@ -59,6 +55,13 @@ proc instFieldLoopBody(c: TFieldInstCtx, n: PNode, forLoop: PNode): PNode =
           result.add(tupl)
           result.add(newSymNode(c.field, n.info))
         break
+  of nkIdentDefs, nkVarTuple, nkConstDef:
+    result = shallowCopy(n)
+    c.leftPartOfDefinition = true
+    result[0] = instFieldLoopBody(c, n[0], forLoop)
+    c.leftPartOfDefinition = false
+    for i in 1..<n.len:
+      result[i] = instFieldLoopBody(c, n[i], forLoop)
   else:
     if n.kind == nkContinueStmt:
       localError(c.c.config, n.info,
@@ -83,9 +86,7 @@ proc semForObjectFields(c: TFieldsCtx, typ, forLoop, father: PNode) =
     )
     openScope(c.c)
     inc c.c.inUnrolledContext
-    var body = instFieldLoopBody(fc, lastSon(forLoop), forLoop)
-    # new scope for each field that codegen should know about:
-    body = wrapNewScope(c.c, body)
+    let body = instFieldLoopBody(fc, lastSon(forLoop), forLoop)
     father.add(semStmt(c.c, body, {}))
     dec c.c.inUnrolledContext
     closeScope(c.c)
@@ -161,8 +162,6 @@ proc semForFields(c: PContext, n: PNode, m: TMagic): PNode =
           replaceByFieldName: m == mFieldPairs
       )
       var body = instFieldLoopBody(fc, loopBody, n)
-      # new scope for each field that codegen should know about:
-      body = wrapNewScope(c, body)
       inc c.inUnrolledContext
       stmts.add(semStmt(c, body, {}))
       dec c.inUnrolledContext

compiler/semfold.nim

@@ -24,7 +24,7 @@ when defined(nimPreviewSlimSystem):
 proc errorType*(g: ModuleGraph): PType =
   ## creates a type representing an error state
   result = newType(tyError, g.idgen, g.owners[^1])
-  result.flagsImpl.incl tfCheckedForDestructor
+  result.flags.incl tfCheckedForDestructor
 
 proc getIntLitTypeG(g: ModuleGraph; literal: PNode; idgen: IdGenerator): PType =
   # we cache some common integer literal types for performance:
@@ -38,7 +38,7 @@ proc newIntNodeT*(intVal: Int128, n: PNode; idgen: IdGenerator; g: ModuleGraph):
   # original type was 'int', not a distinct int etc.
   if n.typ.kind == tyInt:
     # access cache for the int lit type
-    result.typ = getIntLitTypeG(g, result, idgen)
+    result.typ() = getIntLitTypeG(g, result, idgen)
   result.info = n.info
 
 proc newFloatNodeT*(floatVal: BiggestFloat, n: PNode; g: ModuleGraph): PNode =
@@ -46,12 +46,12 @@ proc newFloatNodeT*(floatVal: BiggestFloat, n: PNode; g: ModuleGraph): PNode =
     result = newFloatNode(nkFloat32Lit, floatVal)
   else:
     result = newFloatNode(nkFloatLit, floatVal)
-  result.typ = n.typ
+  result.typ() = n.typ
   result.info = n.info
 
 proc newStrNodeT*(strVal: string, n: PNode; g: ModuleGraph): PNode =
   result = newStrNode(nkStrLit, strVal)
-  result.typ = n.typ
+  result.typ() = n.typ
   result.info = n.info
 
 proc getConstExpr*(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
@@ -319,7 +319,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
   of mEnumToStr: result = newStrNodeT(ordinalValToString(a, g), n, g)
   of mArrToSeq:
     result = copyTree(a)
-    result.typ = n.typ
+    result.typ() = n.typ
   of mCompileOption:
     result = newIntNodeT(toInt128(ord(commands.testCompileOption(g.config, a.getStr, n.info))), n, idgen, g)
   of mCompileOptionArg:
@@ -414,7 +414,7 @@ proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): P
       result = newIntNodeT(toInt128(a.getOrdValue != 0), n, idgen, g)
     of tyBool, tyEnum: # xxx shouldn't we disallow `tyEnum`?
       result = a
-      result.typ = n.typ
+      result.typ() = n.typ
     else:
       raiseAssert $srcTyp.kind
   of tyInt..tyInt64, tyUInt..tyUInt64:
@@ -431,7 +431,7 @@ proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): P
         result = newIntNodeT(val, n, idgen, g)
     else:
       result = a
-      result.typ = n.typ
+      result.typ() = n.typ
     if check and result.kind in {nkCharLit..nkUInt64Lit} and
           dstTyp.kind notin {tyUInt..tyUInt64}:
       rangeCheck(n, getInt(result), g)
@@ -441,12 +441,12 @@ proc foldConv(n, a: PNode; idgen: IdGenerator; g: ModuleGraph; check = false): P
       result = newFloatNodeT(toFloat64(getOrdValue(a)), n, g)
     else:
       result = a
-      result.typ = n.typ
+      result.typ() = n.typ
   of tyOpenArray, tyVarargs, tyProc, tyPointer:
     result = nil
   else:
     result = a
-    result.typ = n.typ
+    result.typ() = n.typ
 
 proc getArrayConstr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
   if n.kind == nkBracket:
@@ -471,20 +471,19 @@ proc foldArrayAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNo
       if result.kind == nkExprColonExpr: result = result[1]
     else:
       result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
   of nkBracket:
     idx -= toInt64(firstOrd(g.config, x.typ))
     if idx >= 0 and idx < x.len: result = x[int(idx)]
     else:
       result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.len-1) & $n)
   of nkStrLit..nkTripleStrLit:
     result = newNodeIT(nkCharLit, x.info, n.typ)
     if idx >= 0 and idx < x.strVal.len:
       result.intVal = ord(x.strVal[int(idx)])
     else:
-      result = nil
-      #localError(g.config, n.info, formatErrorIndexBound(idx, x.strVal.len-1) & $n)
+      localError(g.config, n.info, formatErrorIndexBound(idx, x.strVal.len-1) & $n)
   else: result = nil
 
 proc foldFieldAccess(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
@@ -518,10 +517,10 @@ proc foldConStrStr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
 proc newSymNodeTypeDesc*(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode =
   result = newSymNode(s, info)
   if s.typ.kind != tyTypeDesc:
-    result.typ = newType(tyTypeDesc, idgen, s.owner)
+    result.typ() = newType(tyTypeDesc, idgen, s.owner)
     result.typ.addSonSkipIntLit(s.typ, idgen)
   else:
-    result.typ = s.typ
+    result.typ() = s.typ
 
 proc foldDefine(m, s: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode =
   result = nil
@@ -590,7 +589,7 @@ proc foldDefine(m, s: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
             raise newException(ValueError, "invalid enum value: " & str)
         else:
           localError(g.config, s.info, "unsupported type $1 for define '$2'" %
-            [typeToString(rawTyp), name])
+            [name, typeToString(rawTyp)])
       except ValueError as e:
         localError(g.config, s.info,
           "could not process define '$1' of type $2; $3" %
@@ -640,7 +639,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
       if s.typ.kind == tyStatic:
         if s.typ.n != nil and tfUnresolved notin s.typ.flags:
           result = s.typ.n
-          result.typ = s.typ.base
+          result.typ() = s.typ.base
       elif s.typ.isIntLit:
         result = s.typ.n
       else:
@@ -753,7 +752,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
     if a == nil: return
     if leValueConv(n[1], a) and leValueConv(a, n[2]):
       result = a              # a <= x and x <= b
-      result.typ = n.typ
+      result.typ() = n.typ
     elif n.typ.kind in {tyUInt..tyUInt64}:
       discard "don't check uints"
     else:
@@ -764,7 +763,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
     var a = getConstExpr(m, n[0], idgen, g)
     if a == nil: return
     result = a
-    result.typ = n.typ
+    result.typ() = n.typ
   of nkHiddenStdConv, nkHiddenSubConv, nkConv:
     var a = getConstExpr(m, n[1], idgen, g)
     if a == nil: return
@@ -781,7 +780,7 @@ proc getConstExpr(m: PSym, n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode
         not (n.typ.kind == tyProc and a.typ.kind == tyProc):
       # we allow compile-time 'cast' for pointer types:
       result = a
-      result.typ = n.typ
+      result.typ() = n.typ
   of nkBracketExpr: result = foldArrayAccess(m, n, idgen, g)
   of nkDotExpr: result = foldFieldAccess(m, n, idgen, g)
   of nkCheckedFieldExpr: